@vibgrate/cli 2026.721.2 → 2026.722.1

package/dist/{chunk-3DPZQS2Q.js → chunk-VXT6LUGP.js}

@@ -1,8 +1,12 @@
-import { hashString, langById, shortId, canonicalize, grammarSetVersion, hashBytes, langForExtension, setGrammarsOverride, parseSource } from './chunk-JWBS5GS6.js';
-import { writeTextFile, pathExists, readJsonFile, loadConfig, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-NHLSAZ6N.js';
-import * as fs17 from 'fs';
+import { resolveOne, resolveVersion, resolveLib, loadCatalog, driftFor, localPackageDocs, readDoc, findNodes, inventory, localApiSurface } from './chunk-GGJZA3Q6.js';
+import { loadConfig, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-JSNHZCIV.js';
+import { langById, grammarSetVersion, langForExtension, setGrammarsOverride, parseSource } from './chunk-PY3DNX5H.js';
+import { writeTextFile, pathExists, readJsonFile } from './chunk-CRAMOEBE.js';
+import { impactOf, indexFor, withTimeout, getNodeEmbeddings, queryGraphSemantic, queryGraph, loadEmbedder, isModelReady, cacheDir, loadCache, stableStringify, serializeGraph, parseGraph, acquireLock, releaseLock } from './chunk-WNIIKCNF.js';
+import { shortId, canonicalize, hashString, hashBytes } from './chunk-JFGYT6BI.js';
+import * as fs18 from 'fs';
 import { spawnSync, execFileSync } from 'child_process';
-import * as path17 from 'path';
+import * as path2 from 'path';
 import ignore from 'ignore';
 import * as v8 from 'v8';
 import Graph from 'graphology';
@@ -11,9 +15,8 @@ import betweenness from 'graphology-metrics/centrality/betweenness.js';
 import eigenvector from 'graphology-metrics/centrality/eigenvector.js';
 import louvain from 'graphology-communities-louvain';
 import * as os from 'os';
-import { pathToFileURL, fileURLToPath } from 'url';
+import { fileURLToPath } from 'url';
 import ts from 'typescript';
-import { createRequire } from 'module';
 import { bidirectional } from 'graphology-shortest-path/unweighted.js';
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
@@ -23,9 +26,6 @@ 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';
 
 var NPX_INVOCATION = "npx @vibgrate/cli";
 function whichOnPath(cmd) {
@@ -41,9 +41,9 @@ function whichOnPath(cmd) {
 }
 function isOwnBinary(binPath) {
   try {
-    const real = fs17.realpathSync(binPath);
+    const real = fs18.realpathSync(binPath);
     if (/[\\/]@vibgrate[\\/]cli[\\/]/.test(real)) return true;
-    const head = fs17.readFileSync(real, { encoding: "utf8" }).slice(0, 2048);
+    const head = fs18.readFileSync(real, { encoding: "utf8" }).slice(0, 2048);
     return head.includes("@vibgrate/cli") || head.includes("vibgrate");
   } catch {
     return false;
@@ -53,7 +53,7 @@ function isEphemeralNpxBinary(binPath) {
   const NPX_SEGMENT = /[\\/]_npx[\\/]/;
   if (NPX_SEGMENT.test(binPath)) return true;
   try {
-    return NPX_SEGMENT.test(fs17.realpathSync(binPath));
+    return NPX_SEGMENT.test(fs18.realpathSync(binPath));
   } catch {
     return false;
   }
@@ -219,19 +219,19 @@ var SKIP_FILES = /* @__PURE__ */ new Set([
   "flake.lock"
 ]);
 function toPosix(p) {
-  return p.split(path17.sep).join("/");
+  return p.split(path2.sep).join("/");
 }
 function buildRootIgnore(root, exclude) {
   const ig = ignore();
-  const gitignorePath = path17.join(root, ".gitignore");
-  if (fs17.existsSync(gitignorePath)) {
-    ig.add(fs17.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path2.join(root, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) {
+    ig.add(fs18.readFileSync(gitignorePath, "utf8"));
   }
   if (exclude.length) ig.add(exclude);
   return ig;
 }
 function discover(options) {
-  const root = path17.resolve(options.root);
+  const root = path2.resolve(options.root);
   const onlyLangs = (options.only ?? []).filter(Boolean);
   const allowLang = (lang) => onlyLangs.length === 0 || onlyLangs.includes(lang.id);
   for (const id of onlyLangs) {
@@ -240,27 +240,27 @@ function discover(options) {
     }
   }
   const rootIg = buildRootIgnore(root, options.exclude ?? []);
-  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path17.resolve(root, p)) : [root]).filter((p) => fs17.existsSync(p));
+  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path2.resolve(root, p)) : [root]).filter((p) => fs18.existsSync(p));
   const found = /* @__PURE__ */ new Map();
   const considerFile = (abs) => {
-    const rel2 = toPosix(path17.relative(root, abs));
+    const rel2 = toPosix(path2.relative(root, abs));
     if (rel2.startsWith("..")) return;
     if (rel2 === "" || rootIg.ignores(rel2)) return;
-    if (SKIP_FILES.has(path17.basename(abs).toLowerCase())) return;
-    const lang = langForExtension(path17.extname(abs));
+    if (SKIP_FILES.has(path2.basename(abs).toLowerCase())) return;
+    const lang = langForExtension(path2.extname(abs));
     if (!lang || !allowLang(lang)) return;
     found.set(rel2, { rel: rel2, abs, lang });
   };
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const abs = path17.join(dir, entry.name);
-      const rel2 = toPosix(path17.relative(root, abs));
+      const abs = path2.join(dir, entry.name);
+      const rel2 = toPosix(path2.relative(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         if (rel2 && rootIg.ignores(`${rel2}/`)) continue;
@@ -271,7 +271,7 @@ function discover(options) {
     }
   };
   for (const scope of scopeAbs) {
-    const stat = fs17.statSync(scope);
+    const stat = fs18.statSync(scope);
     if (stat.isDirectory()) walk2(scope);
     else if (stat.isFile()) considerFile(scope);
   }
@@ -455,10 +455,10 @@ function buildModuleResolver(root, relSet) {
     resolve(fromRel, source) {
       if (source.includes("\\")) source = source.split("\\").join(".");
       if (source.startsWith("./") || source.startsWith("../")) {
-        return probe(posixJoin(path17.posix.dirname(fromRel), source));
+        return probe(posixJoin(path2.posix.dirname(fromRel), source));
       }
       if (/\.[A-Za-z0-9]+$/.test(source) && !source.startsWith("<")) {
-        const hit = probe(posixJoin(path17.posix.dirname(fromRel), source));
+        const hit = probe(posixJoin(path2.posix.dirname(fromRel), source));
         if (hit) return hit;
       }
       if (source.startsWith(".")) {
@@ -471,11 +471,11 @@ function buildModuleResolver(root, relSet) {
 function buildSuffixIndex(relSet) {
   const byLast = /* @__PURE__ */ new Map();
   for (const rel2 of relSet) {
-    const dot2 = rel2.lastIndexOf(".");
-    if (dot2 < 0) continue;
-    const ext = rel2.slice(dot2);
+    const dot = rel2.lastIndexOf(".");
+    if (dot < 0) continue;
+    const ext = rel2.slice(dot);
     if (!EXT_GROUPS[ext]) continue;
-    let key = rel2.slice(0, dot2);
+    let key = rel2.slice(0, dot);
     const base = key.slice(key.lastIndexOf("/") + 1);
     if (base === "__init__" || base === "index") {
       key = key.slice(0, Math.max(0, key.length - base.length - 1));
@@ -494,12 +494,12 @@ function resolveSuffix(index, fromRel, source) {
   const fromExt = fromDot >= 0 ? fromRel.slice(fromDot) : "";
   const allowed = EXT_GROUPS[fromExt];
   if (!allowed) return null;
-  const q2 = source.replace(/\./g, "/");
-  const last = q2.slice(q2.lastIndexOf("/") + 1);
+  const q = source.replace(/\./g, "/");
+  const last = q.slice(q.lastIndexOf("/") + 1);
   const cands = index.get(last);
   if (!cands) return null;
   const matches = cands.filter(
-    (c) => allowed.includes(c.ext) && (c.key === q2 || c.key.endsWith("/" + q2))
+    (c) => allowed.includes(c.ext) && (c.key === q || c.key.endsWith("/" + q))
   );
   if (matches.length === 0) return null;
   if (matches.length === 1) return matches[0].rel;
@@ -529,8 +529,8 @@ function resolvePyRelative(probe, fromRel, source) {
   let dots = 0;
   while (source[dots] === ".") dots++;
   const rest = source.slice(dots);
-  let dir = path17.posix.dirname(fromRel);
-  for (let i = 1; i < dots; i++) dir = path17.posix.dirname(dir);
+  let dir = path2.posix.dirname(fromRel);
+  for (let i = 1; i < dots; i++) dir = path2.posix.dirname(dir);
   const sub = rest.replace(/\./g, "/");
   return probe(sub ? posixJoin(dir, sub) : dir);
 }
@@ -538,7 +538,7 @@ function relativeResolver(relSet) {
   const probe = makeProbe(relSet);
   return {
     resolve(fromRel, source) {
-      if (source.startsWith(".")) return probe(posixJoin(path17.posix.dirname(fromRel), source));
+      if (source.startsWith(".")) return probe(posixJoin(path2.posix.dirname(fromRel), source));
       return resolveDotted(probe, source);
     }
   };
@@ -556,12 +556,12 @@ function makeProbe(relSet) {
   };
 }
 function normalizeRel(p) {
-  const norm = path17.posix.normalize(p);
+  const norm = path2.posix.normalize(p);
   const stripped = norm.startsWith("./") ? norm.slice(2) : norm;
   return stripped.startsWith("..") ? "" : stripped;
 }
 function posixJoin(a, b) {
-  return path17.posix.normalize(path17.posix.join(a, b));
+  return path2.posix.normalize(path2.posix.join(a, b));
 }
 function matchPattern(pattern, source) {
   const star = pattern.indexOf("*");
@@ -574,8 +574,8 @@ function matchPattern(pattern, source) {
 }
 function loadTsconfigPaths(root) {
   for (const name of ["tsconfig.base.json", "tsconfig.json"]) {
-    const file = path17.join(root, name);
-    if (fs17.existsSync(file)) {
+    const file = path2.join(root, name);
+    if (fs18.existsSync(file)) {
       const merged = readTsconfigChain(root, file, /* @__PURE__ */ new Set());
       if (merged && merged.paths.length) return merged;
     }
@@ -587,21 +587,21 @@ function readTsconfigChain(root, file, seen) {
   seen.add(file);
   let cfg;
   try {
-    cfg = parseJsonc(fs17.readFileSync(file, "utf8"));
+    cfg = parseJsonc(fs18.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
-  const dir = path17.dirname(file);
+  const dir = path2.dirname(file);
   let base = { baseUrlRel: "", paths: [] };
   if (cfg.extends && cfg.extends.startsWith(".")) {
-    const extPath = path17.resolve(dir, cfg.extends.endsWith(".json") ? cfg.extends : `${cfg.extends}.json`);
-    if (fs17.existsSync(extPath)) {
+    const extPath = path2.resolve(dir, cfg.extends.endsWith(".json") ? cfg.extends : `${cfg.extends}.json`);
+    if (fs18.existsSync(extPath)) {
       const inherited = readTsconfigChain(root, extPath, seen);
       if (inherited) base = inherited;
     }
   }
   const co = cfg.compilerOptions ?? {};
-  const baseUrlRel = co.baseUrl !== void 0 ? path17.relative(root, path17.resolve(dir, co.baseUrl)).split(path17.sep).join("/") : base.baseUrlRel;
+  const baseUrlRel = co.baseUrl !== void 0 ? path2.relative(root, path2.resolve(dir, co.baseUrl)).split(path2.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 };
@@ -609,27 +609,27 @@ function readTsconfigChain(root, file, seen) {
 function loadWorkspacePackages(root) {
   const map = /* @__PURE__ */ new Map();
   const globs = [];
-  const rootPkg = path17.join(root, "package.json");
-  if (fs17.existsSync(rootPkg)) {
+  const rootPkg = path2.join(root, "package.json");
+  if (fs18.existsSync(rootPkg)) {
     try {
-      const pkg = JSON.parse(fs17.readFileSync(rootPkg, "utf8"));
+      const pkg = JSON.parse(fs18.readFileSync(rootPkg, "utf8"));
       const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
       if (ws) globs.push(...ws);
     } catch {
     }
   }
-  const pnpmWs = path17.join(root, "pnpm-workspace.yaml");
-  if (fs17.existsSync(pnpmWs)) {
-    for (const line of fs17.readFileSync(pnpmWs, "utf8").split("\n")) {
+  const pnpmWs = path2.join(root, "pnpm-workspace.yaml");
+  if (fs18.existsSync(pnpmWs)) {
+    for (const line of fs18.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 = path17.join(dir, "package.json");
+    const pj = path2.join(dir, "package.json");
     try {
-      const name = JSON.parse(fs17.readFileSync(pj, "utf8")).name;
-      if (name) map.set(name, path17.relative(root, dir).split(path17.sep).join("/"));
+      const name = JSON.parse(fs18.readFileSync(pj, "utf8")).name;
+      if (name) map.set(name, path2.relative(root, dir).split(path2.sep).join("/"));
     } catch {
     }
   }
@@ -639,10 +639,10 @@ function expandWorkspaceGlobs(root, globs) {
   const out = /* @__PURE__ */ new Set();
   for (const glob of globs) {
     const clean = glob.replace(/\/\*\*$/, "").replace(/\/\*$/, "");
-    const baseDir = path17.join(root, clean);
+    const baseDir = path2.join(root, clean);
     const recurse = glob.endsWith("**");
     if (glob === clean) {
-      if (fs17.existsSync(path17.join(baseDir, "package.json"))) out.add(baseDir);
+      if (fs18.existsSync(path2.join(baseDir, "package.json"))) out.add(baseDir);
       continue;
     }
     collectPackageDirs(baseDir, recurse ? 4 : 1, out);
@@ -653,14 +653,14 @@ function collectPackageDirs(dir, depth, out) {
   if (depth < 0) return;
   let entries;
   try {
-    entries = fs17.readdirSync(dir, { withFileTypes: true });
+    entries = fs18.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (!e.isDirectory() || e.name === "node_modules" || e.name.startsWith(".")) continue;
-    const child = path17.join(dir, e.name);
-    if (fs17.existsSync(path17.join(child, "package.json"))) out.add(child);
+    const child = path2.join(dir, e.name);
+    if (fs18.existsSync(path2.join(child, "package.json"))) out.add(child);
     else collectPackageDirs(child, depth - 1, out);
   }
 }
@@ -1159,14 +1159,14 @@ var DEFAULT_PATHS = [
 ];
 function loadCoverage(root, explicit) {
   const candidates = (explicit && explicit.length ? explicit : DEFAULT_PATHS).map(
-    (p) => path17.resolve(root, p)
+    (p) => path2.resolve(root, p)
   );
-  const found = candidates.filter((p) => fs17.existsSync(p));
+  const found = candidates.filter((p) => fs18.existsSync(p));
   if (found.length === 0) return null;
   const map = /* @__PURE__ */ new Map();
   for (const file of found) {
     try {
-      const text = fs17.readFileSync(file, "utf8");
+      const text = fs18.readFileSync(file, "utf8");
       if (file.endsWith(".json")) mergeIstanbul(map, text, root);
       else mergeLcov(map, text, root);
     } catch {
@@ -1175,8 +1175,8 @@ function loadCoverage(root, explicit) {
   return map.size ? map : null;
 }
 function rel(root, p) {
-  const abs = path17.isAbsolute(p) ? p : path17.resolve(root, p);
-  return path17.relative(root, abs).split(path17.sep).join("/");
+  const abs = path2.isAbsolute(p) ? p : path2.resolve(root, p);
+  return path2.relative(root, abs).split(path2.sep).join("/");
 }
 function bump(map, file, line, hits) {
   let lh = map.get(file);
@@ -1464,32 +1464,6 @@ function matchConfidence(entry, nameParts, imports, callees) {
   return conf;
 }
 
-// src/engine/serialize.ts
-function serializeGraph(graph) {
-  return `${stableStringify(graph, 2)}
-`;
-}
-function stableStringify(value, indent = 2) {
-  return JSON.stringify(sortKeys(value), null, indent);
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
-  if (value && typeof value === "object") {
-    const input = value;
-    const out = {};
-    for (const key of Object.keys(input).sort()) {
-      const v = input[key];
-      if (v === void 0) continue;
-      out[key] = sortKeys(v);
-    }
-    return out;
-  }
-  return value;
-}
-function parseGraph(json) {
-  return JSON.parse(json);
-}
-
 // src/schema.ts
 var SCHEMA_VERSION = "vg-graph/1.0";
 var DEFAULT_INLINE_THRESHOLD = 24;
@@ -1512,7 +1486,7 @@ async function parseInline(files, options) {
   onProgress?.(0, files.length);
   for (const file of files) {
     try {
-      const source = fs17.readFileSync(file.abs, "utf8");
+      const source = fs18.readFileSync(file.abs, "utf8");
       out.push(await parseSource(file.rel, file.lang.id, source));
     } catch (err) {
       out.push(emptyParse(file, `parse failed: ${err.message}`));
@@ -1567,9 +1541,9 @@ function isWorkerOom(err) {
   return e?.code === "ERR_WORKER_OUT_OF_MEMORY" || /out of memory/i.test(e?.message ?? "");
 }
 function resolveWorkerFile() {
-  const here = path17.dirname(fileURLToPath(import.meta.url));
-  const candidate = path17.join(here, "parse-worker.js");
-  return fs17.existsSync(candidate) ? candidate : null;
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidate = path2.join(here, "parse-worker.js");
+  return fs18.existsSync(candidate) ? candidate : null;
 }
 function chunk(items, buckets) {
   const out = Array.from({ length: Math.min(buckets, items.length || 1) }, () => []);
@@ -1608,7 +1582,7 @@ function resolve4(parses, resolver) {
     addNode(baseNodes, {
       id: fileId,
       kind: "file",
-      name: path17.posix.basename(p.rel),
+      name: path2.posix.basename(p.rel),
       qualifiedName: p.rel,
       file: p.rel,
       span: { start: 1, end: 1 },
@@ -1646,6 +1620,38 @@ function resolve4(parses, resolver) {
       push(defsByFile, p.rel, ref);
     }
   }
+  const filesByNamespace = /* @__PURE__ */ new Map();
+  for (const p of parses) for (const ns of p.namespaces ?? []) addToSet(filesByNamespace, ns, p.rel);
+  const relsByLang = /* @__PURE__ */ new Map();
+  for (const p of parses) push(relsByLang, p.lang, p.rel);
+  const nsReachableByRel = /* @__PURE__ */ new Map();
+  const moduleReachableByRel = /* @__PURE__ */ new Map();
+  for (const p of parses) {
+    if (MODULE_SCOPED_LANGS.has(p.lang)) {
+      const mod2 = /* @__PURE__ */ new Set();
+      for (const rel2 of relsByLang.get(p.lang) ?? []) if (rel2 !== p.rel) mod2.add(rel2);
+      moduleReachableByRel.set(p.rel, mod2);
+    }
+    const reach = /* @__PURE__ */ new Set();
+    const namespaces = new Set(p.namespaces ?? []);
+    for (const imp of p.imports) {
+      namespaces.add(imp.source);
+      if (IMPORT_NAMES_A_TYPE.has(p.lang)) {
+        const sep9 = Math.max(imp.source.lastIndexOf("."), imp.source.lastIndexOf("\\"));
+        if (sep9 > 0) namespaces.add(imp.source.slice(0, sep9));
+      }
+    }
+    for (const ns of namespaces) for (const rel2 of filesByNamespace.get(ns) ?? []) if (rel2 !== p.rel) reach.add(rel2);
+    nsReachableByRel.set(p.rel, reach);
+  }
+  const superTypesByType = /* @__PURE__ */ new Map();
+  for (const p of parses) {
+    const localDefs = defsByFile.get(p.rel) ?? [];
+    for (const h of p.heritage) {
+      const encl = enclosingDefRef(localDefs, h.byte);
+      if (encl && (encl.kind === "class" || encl.kind === "interface")) addToSet(superTypesByType, encl.name, h.superName);
+    }
+  }
   const edges = new EdgeSet();
   const unresolved2 = /* @__PURE__ */ new Map();
   const stats = {
@@ -1689,9 +1695,11 @@ function resolve4(parses, resolver) {
     const localDefs = defsByFile.get(p.rel) ?? [];
     const imported = importedFilesByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
     const testCaller = isTestFile(p.rel);
+    const nsReach = nsReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const modReach = moduleReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
     for (const call of p.calls) {
       const srcId = enclosingDefId(localDefs, call.byte) ?? fileId;
-      const resolved = resolveCall(call, p.rel, p.lang, imported, defsByName, srcId, testCaller);
+      const resolved = resolveCall(call, p.rel, p.lang, imported, defsByName, srcId, testCaller, nsReach, superTypesByType, modReach);
       if (resolved) {
         edges.add("call", srcId, resolved.id, "heuristic", resolved.confidence);
         stats.callsResolved++;
@@ -1706,9 +1714,11 @@ function resolve4(parses, resolver) {
     const localDefs = defsByFile.get(p.rel) ?? [];
     const imported = importedFilesByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
     const testCaller = isTestFile(p.rel);
+    const nsReach = nsReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+    const modReach = moduleReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
     for (const ref of p.typeRefs) {
       const srcId = enclosingDefId(localDefs, ref.byte) ?? fileId;
-      const target = resolveType(ref.name, p.rel, p.lang, imported, defsByName, testCaller);
+      const target = resolveType(ref.name, p.rel, p.lang, imported, defsByName, testCaller, nsReach, modReach);
       if (target) edges.add("references", srcId, target.id, "heuristic", 0.7);
     }
   }
@@ -1719,7 +1729,9 @@ function resolve4(parses, resolver) {
     for (const h of p.heritage) {
       const srcId = enclosingDefId(localDefs, h.byte);
       if (!srcId) continue;
-      const target = resolveType(h.superName, p.rel, p.lang, imported, defsByName, testCaller);
+      const nsReach = nsReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+      const modReach = moduleReachableByRel.get(p.rel) ?? /* @__PURE__ */ new Set();
+      const target = resolveType(h.superName, p.rel, p.lang, imported, defsByName, testCaller, nsReach, modReach);
       if (target) edges.add(h.kind, srcId, target.id, "heuristic", 0.85);
       else bumpUnresolved(unresolved2, srcId, h.superName, h.kind, p.rel);
     }
@@ -1770,21 +1782,52 @@ function parentQualifiedName(qn) {
   const idx = qn.lastIndexOf(".");
   return idx > 0 ? qn.slice(0, idx) : null;
 }
-function enclosingDefId(defs, byte) {
+function enclosingDefRef(defs, byte) {
   let best;
   for (const d of defs) {
     if (d.startByte <= byte && d.endByte >= byte) {
       if (!best || d.endByte - d.startByte < best.endByte - best.startByte) best = d;
     }
   }
-  return best?.id;
+  return best;
+}
+function enclosingDefId(defs, byte) {
+  return enclosingDefRef(defs, byte)?.id;
+}
+function addToSet(map, key, value) {
+  const s = map.get(key);
+  if (s) s.add(value);
+  else map.set(key, /* @__PURE__ */ new Set([value]));
+}
+function parentTypeName(qualifiedName) {
+  const i = qualifiedName.lastIndexOf(".");
+  return i > 0 ? qualifiedName.slice(0, i) : null;
+}
+function disambiguateInterfaceImpl(pool, superTypesByType) {
+  const withParent = pool.map((c) => ({ c, parent: parentTypeName(c.qualifiedName) })).filter((x) => x.parent !== null);
+  if (withParent.length < 2) return null;
+  const parents = new Set(withParent.map((x) => x.parent));
+  const impls = withParent.filter(
+    (x) => [...parents].some((other) => other !== x.parent && superTypesByType.get(x.parent)?.has(other))
+  );
+  if (impls.length === 0) return null;
+  const interfaceParents = /* @__PURE__ */ new Set();
+  for (const impl of impls) for (const s of superTypesByType.get(impl.parent) ?? []) interfaceParents.add(s);
+  const interfaces = withParent.filter((x) => interfaceParents.has(x.parent));
+  const uniqueImplIds = new Set(impls.map((x) => x.c.id));
+  if (uniqueImplIds.size === 1) return impls[0].c;
+  const uniqueIfaceIds = new Set(interfaces.map((x) => x.c.id));
+  if (uniqueIfaceIds.size === 1) return interfaces[0].c;
+  return null;
 }
 var PACKAGE_SCOPED_LANGS = /* @__PURE__ */ new Set(["go", "java", "cs", "kotlin", "scala", "swift"]);
+var IMPORT_NAMES_A_TYPE = /* @__PURE__ */ new Set(["java", "kotlin", "scala", "php"]);
+var MODULE_SCOPED_LANGS = /* @__PURE__ */ new Set(["swift"]);
 function dirOf(rel2) {
   const i = rel2.lastIndexOf("/");
   return i >= 0 ? rel2.slice(0, i) : "";
 }
-function resolveCall(call, fromRel, fromLang, importedRels, defsByName, enclosingId, fromIsTestFile = false) {
+function resolveCall(call, fromRel, fromLang, importedRels, defsByName, enclosingId, fromIsTestFile = false, nsReachableRels = /* @__PURE__ */ new Set(), superTypesByType = /* @__PURE__ */ new Map(), moduleReachableRels = /* @__PURE__ */ new Set()) {
   const candidates = defsByName.get(call.callee);
   if (!candidates || candidates.length === 0) return null;
   const callable = candidates.filter((c) => c.kind === "function" || c.kind === "method");
@@ -1796,21 +1839,24 @@ function resolveCall(call, fromRel, fromLang, importedRels, defsByName, enclosin
     const pick = [...sameFile].sort((a, b) => a.id.localeCompare(b.id))[0];
     return { id: pick.id, confidence: 0.4 };
   }
-  const imported = pool.filter((c) => importedRels.has(c.rel));
-  if (imported.length === 1) return { id: imported[0].id, confidence: 0.75 };
-  if (imported.length > 1) return null;
-  if (PACKAGE_SCOPED_LANGS.has(fromLang)) {
-    const dir = dirOf(fromRel);
-    let samePkg = pool.filter((c) => c.lang === fromLang && dirOf(c.rel) === dir);
-    if (call.qualified && enclosingId) samePkg = samePkg.filter((c) => c.id !== enclosingId);
-    if (samePkg.length === 1) return { id: samePkg[0].id, confidence: 0.7 };
+  const dir = dirOf(fromRel);
+  const notSelf = (c) => !(call.qualified && enclosingId && c.id === enclosingId);
+  const strict = pool.filter(
+    (c) => notSelf(c) && (importedRels.has(c.rel) || PACKAGE_SCOPED_LANGS.has(fromLang) && c.lang === fromLang && dirOf(c.rel) === dir || nsReachableRels.has(c.rel))
+  );
+  if (strict.length === 1) return { id: strict[0].id, confidence: 0.75 };
+  const broad = pool.filter((c) => notSelf(c) && (moduleReachableRels.has(c.rel) || strict.includes(c)));
+  if (broad.length > 1) {
+    const dedup = disambiguateInterfaceImpl(broad, superTypesByType);
+    if (dedup) return { id: dedup.id, confidence: 0.6 };
   }
+  if (strict.length > 1) return null;
   if (fromLang === "swift" && fromIsTestFile && pool.length === 1) {
     return { id: pool[0].id, confidence: 0.5 };
   }
   return null;
 }
-function resolveType(name, fromRel, fromLang, importedRels, defsByName, fromIsTestFile = false) {
+function resolveType(name, fromRel, fromLang, importedRels, defsByName, fromIsTestFile = false, nsReachableRels = /* @__PURE__ */ new Set(), moduleReachableRels = /* @__PURE__ */ new Set()) {
   const candidates = (defsByName.get(name) ?? []).filter(
     (c) => c.kind === "class" || c.kind === "interface"
   );
@@ -1825,6 +1871,10 @@ function resolveType(name, fromRel, fromLang, importedRels, defsByName, fromIsTe
     const samePkg = candidates.filter((c) => c.lang === fromLang && dirOf(c.rel) === dir);
     if (samePkg.length === 1) return { id: samePkg[0].id };
   }
+  if (nsReachableRels.size || moduleReachableRels.size) {
+    const reach = candidates.filter((c) => nsReachableRels.has(c.rel) || moduleReachableRels.has(c.rel));
+    if (reach.length === 1) return { id: reach[0].id };
+  }
   if (fromLang === "swift" && fromIsTestFile && candidates.length === 1) {
     return { id: candidates[0].id };
   }
@@ -1881,6 +1931,9 @@ function tsResolveEdges(root, tsFiles, nodes) {
   const edges = /* @__PURE__ */ new Map();
   const covered = /* @__PURE__ */ new Set();
   const stats = empty.stats;
+  const interfaceCalls = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const list of nodesByFile.values()) for (const n of list) byId.set(n.id, n);
   for (const file of tsFiles) {
     const sf = program.getSourceFile(file.abs);
     if (!sf) continue;
@@ -1898,6 +1951,9 @@ function tsResolveEdges(root, tsFiles, nodes) {
           if (src && src.id !== target.id) {
             add2(edges, callKind(target), src.id, target.id);
             stats.resolved++;
+            if (target.kind === "interface" && ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+              interfaceCalls.push({ srcId: src.id, interfaceId: target.id, method: node.expression.name.text });
+            }
           }
         }
       } else if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
@@ -1931,6 +1987,27 @@ function tsResolveEdges(root, tsFiles, nodes) {
     };
     visit(sf);
   }
+  const implsByInterface = /* @__PURE__ */ new Map();
+  for (const e of edges.values()) {
+    if (e.kind !== "implements" && e.kind !== "extends") continue;
+    if (byId.get(e.dst)?.kind !== "interface") continue;
+    const list = implsByInterface.get(e.dst);
+    if (list) list.push(e.src);
+    else implsByInterface.set(e.dst, [e.src]);
+  }
+  for (const { srcId, interfaceId, method } of interfaceCalls) {
+    const impls = implsByInterface.get(interfaceId);
+    if (!impls || impls.length !== 1) continue;
+    const impl = byId.get(impls[0]);
+    if (!impl) continue;
+    const target = (nodesByFile.get(impl.file) ?? []).find(
+      (n) => (n.kind === "method" || n.kind === "function") && n.qualifiedName === `${impl.qualifiedName}.${method}`
+    );
+    if (target && target.id !== srcId) {
+      add2(edges, "call", srcId, target.id);
+      stats.resolved++;
+    }
+  }
   return { edges: [...edges.values()], coveredFiles: covered, stats };
 }
 function callKind(target) {
@@ -2044,50 +2121,7 @@ function enclosing3(nodes, line) {
   return best;
 }
 function normalize2(p) {
-  return path17.resolve(p).split(path17.sep).join("/");
-}
-var CACHE_VERSION = "vg-parse-cache/2";
-function cacheDir(root) {
-  return path17.join(root, ".vibgrate", "cache");
-}
-function cachePath(root) {
-  return path17.join(cacheDir(root), "parse-cache.json");
-}
-function loadCache(root, opts) {
-  const file = cachePath(root);
-  let data = {
-    version: CACHE_VERSION,
-    toolVersion: opts.toolVersion,
-    grammars: opts.grammars,
-    entries: {}
-  };
-  if (!opts.disabled && fs17.existsSync(file)) {
-    try {
-      const loaded = JSON.parse(fs17.readFileSync(file, "utf8"));
-      if (loaded.version === CACHE_VERSION && loaded.toolVersion === opts.toolVersion && loaded.grammars === opts.grammars && loaded.entries) {
-        data = loaded;
-      }
-    } catch {
-    }
-  }
-  return {
-    get(rel2, hash) {
-      const entry = data.entries[rel2];
-      return entry && entry.hash === hash ? entry.parse : void 0;
-    },
-    set(rel2, parse) {
-      data.entries[rel2] = { hash: parse.hash, parse };
-    },
-    prune(currentRels) {
-      for (const rel2 of Object.keys(data.entries)) {
-        if (!currentRels.has(rel2)) delete data.entries[rel2];
-      }
-    },
-    save() {
-      fs17.mkdirSync(cacheDir(root), { recursive: true });
-      fs17.writeFileSync(file, stableStringify(data, 0));
-    }
-  };
+  return path2.resolve(p).split(path2.sep).join("/");
 }
 
 // src/engine/epistemic.ts
@@ -2117,7 +2151,7 @@ function epistemicBreakdown(edges) {
 // src/engine/build.ts
 async function buildGraph(options) {
   const start = nowMs();
-  const root = path17.resolve(options.root);
+  const root = path2.resolve(options.root);
   const files = discover({
     root,
     only: options.only,
@@ -2145,7 +2179,7 @@ async function buildGraph(options) {
   for (const file of files) {
     let stat;
     try {
-      stat = fs17.statSync(file.abs);
+      stat = fs18.statSync(file.abs);
     } catch {
       continue;
     }
@@ -2163,7 +2197,7 @@ async function buildGraph(options) {
     }
     let hash = "";
     try {
-      hash = hashBytes(fs17.readFileSync(file.abs));
+      hash = hashBytes(fs18.readFileSync(file.abs));
     } catch {
       continue;
     }
@@ -2255,7 +2289,7 @@ async function buildGraph(options) {
       toolchain
     },
     meta: {
-      root: path17.basename(root) === "" ? "." : ".",
+      root: path2.basename(root) === "" ? "." : ".",
       languages,
       counts: {
         nodes: analysis.nodes.length,
@@ -2301,14 +2335,14 @@ function toRepoRel(p) {
 function loadScipIndex(root, explicit) {
   const candidates = [
     explicit,
-    path17.join(root, "index.scip"),
-    path17.join(root, ".vibgrate", "index.scip")
+    path2.join(root, "index.scip"),
+    path2.join(root, ".vibgrate", "index.scip")
   ].filter((p) => Boolean(p));
   for (const file of candidates) {
-    const abs = path17.isAbsolute(file) ? file : path17.resolve(root, file);
-    if (!fs17.existsSync(abs)) continue;
+    const abs = path2.isAbsolute(file) ? file : path2.resolve(root, file);
+    if (!fs18.existsSync(abs)) continue;
     try {
-      const index = decodeScipIndex(new Uint8Array(fs17.readFileSync(abs)));
+      const index = decodeScipIndex(new Uint8Array(fs18.readFileSync(abs)));
       if (index.documents.length) {
         return { index, tool: index.toolVersion ? `${index.toolName} ${index.toolVersion}` : index.toolName };
       }
@@ -2469,7 +2503,7 @@ function esc(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function vibgrateDir(root) {
-  return path17.join(root, ".vibgrate");
+  return path2.join(root, ".vibgrate");
 }
 var DEFAULT_GITIGNORE = [
   "# Created once by vg \u2014 local graph artifacts stay out of git by default.",
@@ -2485,51 +2519,51 @@ var DEFAULT_GITIGNORE = [
   "mcp-navigation.json"
 ];
 function ensureVibgrateGitignore(root) {
-  const file = path17.join(vibgrateDir(root), ".gitignore");
-  if (fs17.existsSync(file)) return;
-  fs17.mkdirSync(vibgrateDir(root), { recursive: true });
-  fs17.writeFileSync(file, `${DEFAULT_GITIGNORE.join("\n")}
+  const file = path2.join(vibgrateDir(root), ".gitignore");
+  if (fs18.existsSync(file)) return;
+  fs18.mkdirSync(vibgrateDir(root), { recursive: true });
+  fs18.writeFileSync(file, `${DEFAULT_GITIGNORE.join("\n")}
 `);
 }
 function defaultGraphPath(root) {
-  return path17.join(vibgrateDir(root), "graph.json");
+  return path2.join(vibgrateDir(root), "graph.json");
 }
 function writeArtifacts(graph, options) {
   const dir = vibgrateDir(options.root);
-  fs17.mkdirSync(dir, { recursive: true });
+  fs18.mkdirSync(dir, { recursive: true });
   ensureVibgrateGitignore(options.root);
   const graphPath = options.graphPath ?? defaultGraphPath(options.root);
-  fs17.mkdirSync(path17.dirname(graphPath), { recursive: true });
+  fs18.mkdirSync(path2.dirname(graphPath), { recursive: true });
   const tmp = `${graphPath}.${process.pid}.tmp`;
   try {
-    fs17.writeFileSync(tmp, serializeGraph(graph));
-    fs17.renameSync(tmp, graphPath);
+    fs18.writeFileSync(tmp, serializeGraph(graph));
+    fs18.renameSync(tmp, graphPath);
   } catch (err) {
-    fs17.rmSync(tmp, { force: true });
+    fs18.rmSync(tmp, { force: true });
     throw err;
   }
   const written = { graphPath };
   if (options.report !== false) {
-    const reportPath = path17.join(dir, "GRAPH_REPORT.md");
-    fs17.writeFileSync(reportPath, renderReport(graph));
+    const reportPath = path2.join(dir, "GRAPH_REPORT.md");
+    fs18.writeFileSync(reportPath, renderReport(graph));
     written.reportPath = reportPath;
   }
   if (options.html !== false) {
-    const htmlPath = path17.join(dir, "graph.html");
-    fs17.writeFileSync(htmlPath, renderHtml(graph));
+    const htmlPath = path2.join(dir, "graph.html");
+    fs18.writeFileSync(htmlPath, renderHtml(graph));
     written.htmlPath = htmlPath;
   }
   if (graph.facts && graph.facts.length) {
-    const factsPath = path17.join(dir, "facts.jsonl");
-    fs17.writeFileSync(factsPath, graph.facts.map((f) => JSON.stringify(f)).join("\n") + "\n");
+    const factsPath = path2.join(dir, "facts.jsonl");
+    fs18.writeFileSync(factsPath, graph.facts.map((f) => JSON.stringify(f)).join("\n") + "\n");
     written.factsPath = factsPath;
   }
   return written;
 }
 function loadGraph(root, graphPath) {
   const file = graphPath ?? defaultGraphPath(root);
-  if (!fs17.existsSync(file)) return null;
-  return parseGraph(fs17.readFileSync(file, "utf8"));
+  if (!fs18.existsSync(file)) return null;
+  return parseGraph(fs18.readFileSync(file, "utf8"));
 }
 
 // src/engine/verify.ts
@@ -2595,361 +2629,23 @@ var CliError = class extends Error {
 function usageError(message) {
   return new CliError(message, ExitCode.USAGE_ERROR);
 }
-var DEFAULT_LOCK_STALE_MS = 15 * 60 * 1e3;
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return e.code === "EPERM";
-  }
-}
-function lockIsStale(file, staleMs) {
-  try {
-    const { pid, at } = JSON.parse(fs17.readFileSync(file, "utf8"));
-    if (typeof at === "number" && Date.now() - at > staleMs) return true;
-    if (typeof pid === "number" && !isProcessAlive(pid)) return true;
-    return false;
-  } catch {
-    return true;
-  }
-}
-function acquireLock(file, staleMs = DEFAULT_LOCK_STALE_MS) {
-  const write = () => {
-    try {
-      fs17.mkdirSync(path17.dirname(file), { recursive: true });
-      const fd = fs17.openSync(file, "wx");
-      fs17.writeFileSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
-      fs17.closeSync(fd);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  if (write()) return true;
-  if (lockIsStale(file, staleMs)) {
-    try {
-      fs17.rmSync(file, { force: true });
-    } catch {
-    }
-    return write();
-  }
-  return false;
-}
-function releaseLock(file) {
-  try {
-    fs17.rmSync(file, { force: true });
-  } catch {
-  }
-}
-
-// src/engine/embeddings.ts
-function resolveEmbedModel(model) {
-  return model ?? "bge-small-en-v1.5";
-}
-function modelCacheDir() {
-  const base = process.env.XDG_CACHE_HOME || path17.join(os.homedir(), ".cache");
-  return path17.join(base, "vibgrate", "models");
-}
-function modelReadyMarker(modelId) {
-  return path17.join(modelCacheDir(), `.ready-${safe(modelId)}`);
-}
-function isModelReady(modelId = resolveEmbedModel()) {
-  return fs17.existsSync(modelReadyMarker(modelId));
-}
-function unavailableMessage(reason) {
-  switch (reason) {
-    case "no-permission":
-      return `semantic search couldn't write its model cache at ${modelCacheDir()} \u2014 using fast lexical search instead. Relocate it with the standard XDG_CACHE_HOME, or run with --local to stay lexical quietly. (No admin/sudo is ever needed \u2014 the cache lives in your home folder.)`;
-    case "download-failed":
-      return `the semantic model isn't downloaded yet and couldn't be fetched (offline?) \u2014 using fast lexical search. It'll try again next time; run with --local to keep lexical without retrying.`;
-    case "not-installed":
-      return `the optional semantic backend isn't available here \u2014 using fast lexical search.`;
-    case "init-failed":
-    default:
-      return `the semantic model couldn't load \u2014 using fast lexical search.`;
-  }
-}
-function modelCacheInfo(modelId = resolveEmbedModel()) {
-  const dir = modelCacheDir();
-  return { dir, present: isModelReady(modelId) || fs17.existsSync(dir), bytes: dirSize(dir) };
-}
-function clearModelCache() {
-  const dir = modelCacheDir();
-  const bytes = dirSize(dir);
-  try {
-    fs17.rmSync(dir, { recursive: true, force: true });
-  } catch {
-  }
-  return bytes;
-}
-function dirSize(dir) {
-  let total = 0;
-  let entries;
-  try {
-    entries = fs17.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return 0;
-  }
-  for (const e of entries) {
-    const p = path17.join(dir, e.name);
-    if (e.isDirectory()) total += dirSize(p);
-    else {
-      try {
-        total += fs17.statSync(p).size;
-      } catch {
-      }
-    }
-  }
-  return total;
-}
-function isPermissionError(e) {
-  const code = e?.code;
-  return code === "EACCES" || code === "EPERM" || code === "EROFS";
-}
-function embeddingsCached(root, modelId) {
-  return fs17.existsSync(path17.join(cacheDir(root), `embeddings-${safe(modelId)}.json`));
-}
-async function loadEmbedder(options = {}) {
-  if (options.local) return null;
-  const modelId = resolveEmbedModel(options.model);
-  if (options.noDownload && !isModelReady(modelId)) return null;
-  const fail = (reason) => {
-    options.onUnavailable?.(reason);
-    return null;
-  };
-  const mod = await importEmbedBackend();
-  if (!mod?.FlagEmbedding) return fail("not-installed");
-  const cache = modelCacheDir();
-  try {
-    fs17.mkdirSync(cache, { recursive: true });
-  } catch (e) {
-    return fail(isPermissionError(e) ? "no-permission" : "init-failed");
-  }
-  try {
-    const model = await withTimeout(
-      mod.FlagEmbedding.init({
-        model: mapModel(mod, modelId),
-        cacheDir: cache,
-        showDownloadProgress: options.showDownloadProgress ?? false
-      }),
-      embedInitTimeoutMs(),
-      "embedding model init timed out"
-    );
-    try {
-      fs17.writeFileSync(modelReadyMarker(modelId), (/* @__PURE__ */ new Date(0)).toISOString());
-    } catch {
-    }
-    return {
-      id: modelId,
-      async embed(texts) {
-        const out = [];
-        for await (const batch of model.embed(texts, 64)) {
-          for (const v of batch) out.push(Array.from(v));
-        }
-        return out;
-      },
-      async embedQuery(text) {
-        const v = await model.queryEmbed(text);
-        return Array.from(v);
-      }
-    };
-  } catch (e) {
-    return fail(isPermissionError(e) ? "no-permission" : "download-failed");
-  }
-}
-async function importEmbedBackend() {
-  const hostDir = process.env.VIBGRATE_EMBEDDER_PATH;
-  if (hostDir) {
-    try {
-      const req = createRequire(path17.join(hostDir, "package.json"));
-      const mod = await import(pathToFileURL(req.resolve("fastembed")).href);
-      const resolved = mod?.FlagEmbedding ? mod : mod?.default;
-      if (resolved?.FlagEmbedding) return resolved;
-    } catch {
-    }
-  }
-  return await import('fastembed').catch(() => null);
-}
-function embedInitTimeoutMs() {
-  const n = Number(process.env.VG_EMBED_TIMEOUT_MS);
-  return Number.isFinite(n) && n > 0 ? n : 6e4;
-}
-async function withTimeout(promise, ms, message) {
-  let timer;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(message)), ms);
-        timer.unref?.();
-      })
-    ]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function mapModel(mod, id) {
-  const m = mod.EmbeddingModel ?? {};
-  if (/bge-small/i.test(id)) return m.BGESmallENV15 ?? m.BGESmallEN ?? id;
-  if (/bge-base/i.test(id)) return m.BGEBaseENV15 ?? id;
-  if (/all-minilm/i.test(id)) return m.AllMiniLML6V2 ?? id;
-  return id;
-}
-var PATH_NOISE = /* @__PURE__ */ new Set([
-  "src",
-  "app",
-  "apps",
-  "lib",
-  "libs",
-  "dist",
-  "build",
-  "out",
-  "index",
-  "main",
-  "packages",
-  "pkg",
-  "test",
-  "tests",
-  "__tests__",
-  "spec",
-  "node_modules",
-  "internal",
-  "com",
-  "example",
-  "demo",
-  "java",
-  "net",
-  "org",
-  "www"
-]);
-function pathContext(file) {
-  const parts = file.split("/");
-  const stem = (parts.pop() ?? "").replace(/\.[^.]+$/, "");
-  const dirs = parts.filter((p) => p && !PATH_NOISE.has(p.toLowerCase()));
-  return [...dirs.slice(-2), stem].filter(Boolean).join(" ");
-}
-function nodeEmbedText(node, areaLabel) {
-  return [node.qualifiedName, node.kind, node.signature ?? "", node.doc ?? "", pathContext(node.file), areaLabel ?? ""].filter(Boolean).join(" ");
-}
-function cosine(a, b) {
-  let dot2 = 0;
-  let na = 0;
-  let nb = 0;
-  const n = Math.min(a.length, b.length);
-  for (let i = 0; i < n; i++) {
-    dot2 += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
-  }
-  if (na === 0 || nb === 0) return 0;
-  return dot2 / (Math.sqrt(na) * Math.sqrt(nb));
-}
-var EMBED_CHUNK = 256;
-var CACHE_WRITE_INTERVAL_MS = 1500;
-function vectorCachePath(root, modelId) {
-  return path17.join(cacheDir(root), `embeddings-${safe(modelId)}.json`);
-}
-function countPending(graph, root, modelId) {
-  const entries = readCacheEntries(vectorCachePath(root, modelId), modelId);
-  const areaLabel = new Map(graph.areas.map((a) => [a.id, a.label]));
-  let pending = 0;
-  for (const n of graph.nodes) {
-    if (n.kind === "file" || n.kind === "external") continue;
-    const h = hashString(nodeEmbedText(n, areaLabel.get(n.area)));
-    const cached2 = entries[n.id];
-    if (!cached2 || cached2.hash !== h) pending++;
-  }
-  return pending;
-}
-function readCacheEntries(file, modelId) {
-  if (!fs17.existsSync(file)) return {};
-  try {
-    const loaded = JSON.parse(fs17.readFileSync(file, "utf8"));
-    if (loaded.model === modelId && loaded.entries) return loaded.entries;
-  } catch {
-  }
-  return {};
-}
-async function getNodeEmbeddings(graph, embedder, root, onProgress) {
-  const file = vectorCachePath(root, embedder.id);
-  let cache = { model: embedder.id, entries: {} };
-  if (fs17.existsSync(file)) {
-    try {
-      const loaded = JSON.parse(fs17.readFileSync(file, "utf8"));
-      if (loaded.model === embedder.id && loaded.entries) cache = loaded;
-    } catch {
-    }
-  }
-  const areaLabel = new Map(graph.areas.map((a) => [a.id, a.label]));
-  const targets = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external");
-  const toEmbed = [];
-  const vectors = /* @__PURE__ */ new Map();
-  for (const n of targets) {
-    const text = nodeEmbedText(n, areaLabel.get(n.area));
-    const h = hashString(text);
-    const cached2 = cache.entries[n.id];
-    if (cached2 && cached2.hash === h) vectors.set(n.id, cached2.vec);
-    else toEmbed.push({ id: n.id, text, hash: h });
-  }
-  const persist = () => {
-    try {
-      fs17.mkdirSync(cacheDir(root), { recursive: true });
-      const tmp = `${file}.tmp.${process.pid}`;
-      fs17.writeFileSync(tmp, JSON.stringify(cache));
-      fs17.renameSync(tmp, file);
-    } catch {
-    }
-  };
-  if (toEmbed.length) {
-    const lock = `${file}.lock`;
-    if (!acquireLock(lock)) return vectors;
-    try {
-      onProgress?.(0, toEmbed.length);
-      let lastWrite = Date.now();
-      for (let i = 0; i < toEmbed.length; i += EMBED_CHUNK) {
-        const slice = toEmbed.slice(i, i + EMBED_CHUNK);
-        const vecs = await embedder.embed(slice.map((t) => t.text));
-        slice.forEach((t, j) => {
-          const vec = vecs[j] ?? [];
-          vectors.set(t.id, vec);
-          cache.entries[t.id] = { hash: t.hash, vec };
-        });
-        onProgress?.(Math.min(i + EMBED_CHUNK, toEmbed.length), toEmbed.length);
-        if (Date.now() - lastWrite >= CACHE_WRITE_INTERVAL_MS) {
-          persist();
-          lastWrite = Date.now();
-        }
-      }
-      const live = new Set(targets.map((n) => n.id));
-      for (const id of Object.keys(cache.entries)) if (!live.has(id)) delete cache.entries[id];
-      persist();
-    } finally {
-      releaseLock(lock);
-    }
-  }
-  return vectors;
-}
-function safe(id) {
-  return id.replace(/[^a-z0-9.-]+/gi, "_");
-}
 var SNAPSHOT_VERSION = "vg-freshness/1";
 function snapshotPath(root) {
-  return path17.join(cacheDir(root), "freshness.json");
+  return path2.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 {
-    fs17.mkdirSync(cacheDir(root), { recursive: true });
-    fs17.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+    fs18.mkdirSync(cacheDir(root), { recursive: true });
+    fs18.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
   } catch {
   }
 }
 function loadSnapshot(root) {
   try {
-    const loaded = JSON.parse(fs17.readFileSync(snapshotPath(root), "utf8"));
+    const loaded = JSON.parse(fs18.readFileSync(snapshotPath(root), "utf8"));
     if (loaded.version === SNAPSHOT_VERSION && loaded.files && typeof loaded.corpusHash === "string") {
       return { ...loaded, scope: loaded.scope ?? {} };
     }
@@ -2985,7 +2681,7 @@ function probeFreshness(root) {
     }
     let stat;
     try {
-      stat = fs17.statSync(file.abs);
+      stat = fs18.statSync(file.abs);
     } catch {
       drift.removed.push(file.rel);
       continue;
@@ -2993,7 +2689,7 @@ function probeFreshness(root) {
     if (stat.size === entry.size && stat.mtimeMs === entry.mtimeMs) continue;
     let hash = "";
     try {
-      hash = hashBytes(fs17.readFileSync(file.abs));
+      hash = hashBytes(fs18.readFileSync(file.abs));
     } catch {
       drift.removed.push(file.rel);
       continue;
@@ -3010,7 +2706,7 @@ function probeFreshness(root) {
   }
   if (absorbed && !hasDrift(drift)) {
     try {
-      fs17.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+      fs18.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
     } catch {
     }
   }
@@ -3033,348 +2729,6 @@ function pruneScope(scope) {
   if (scope.grammarsDir) out.grammarsDir = scope.grammarsDir;
   return out;
 }
-
-// src/engine/relations.ts
-var GraphIndex = class {
-  constructor(graph) {
-    this.graph = graph;
-    for (const n of graph.nodes) this.nodeById.set(n.id, n);
-    for (const e of graph.edges) {
-      push2(this.outById, e.src, e);
-      push2(this.inById, e.dst, e);
-    }
-  }
-  graph;
-  nodeById = /* @__PURE__ */ new Map();
-  outById = /* @__PURE__ */ new Map();
-  inById = /* @__PURE__ */ new Map();
-  out(id, kind) {
-    const all = this.outById.get(id) ?? [];
-    return kind ? all.filter((e) => e.kind === kind) : all;
-  }
-  in(id, kind) {
-    const all = this.inById.get(id) ?? [];
-    return kind ? all.filter((e) => e.kind === kind) : all;
-  }
-  node(id) {
-    return this.nodeById.get(id);
-  }
-  /**
-   * Resolved nodes called by `id` — invocations (`call`) plus structural
-   * dependency references (`references`, e.g. a constructor-injected field's
-   * type), since both represent real usage a caller/impact question cares
-   * about. `references` is otherwise only emitted by the precise SCIP/tsc
-   * rungs and (for Java DI wiring) the heuristic rung — never a guess.
-   */
-  callees(id) {
-    return this.resolveTargets(this.out(id).filter(isUsageEdge), "dst");
-  }
-  /** Resolved nodes that call or structurally reference `id`. */
-  callers(id) {
-    return this.resolveTargets(this.in(id).filter(isUsageEdge), "src");
-  }
-  resolveTargets(edges, end) {
-    const out = [];
-    for (const e of edges) {
-      const node = this.nodeById.get(e[end]);
-      if (node) out.push({ edge: e, node });
-    }
-    return out;
-  }
-};
-var USAGE_KINDS = /* @__PURE__ */ new Set(["call", "references"]);
-function isUsageEdge(e) {
-  return USAGE_KINDS.has(e.kind);
-}
-function push2(map, key, value) {
-  const list = map.get(key);
-  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([
-  "the",
-  "a",
-  "an",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "to",
-  "of",
-  "in",
-  "on",
-  "for",
-  "and",
-  "or",
-  "where",
-  "what",
-  "which",
-  "how",
-  "do",
-  "does",
-  "did",
-  "i",
-  "we",
-  "it",
-  "this",
-  "that",
-  "with",
-  "when",
-  "who",
-  "why",
-  "can",
-  "should",
-  "my",
-  "our",
-  "you",
-  "your",
-  "from",
-  "by",
-  "at",
-  "as",
-  // Discovery-question scaffolding: words a caller uses to FRAME the ask
-  // ("find the code responsible for X", "I need to modify X, where do I
-  // start?", "explain how X works in this codebase") rather than to name the
-  // target. Left in, these compete on equal footing with the real identifier
-  // terms and can outrank it outright — e.g. "find the code responsible for
-  // deleteAsync" let "find" alone drag in every FindByIdAsync/FindAll method
-  // in the repo, none of them the target (VG-LOCATE-FAILURE-ANALYSIS.md).
-  "find",
-  "code",
-  "responsible",
-  "need",
-  "modify",
-  "me",
-  "implementation",
-  "explain",
-  "works",
-  "codebase",
-  "contains",
-  "file"
-]);
-function queryGraph(graph, question, options = {}) {
-  const budget = options.budget ?? 2e3;
-  const limit = options.limit ?? 12;
-  const terms = tokenize(question);
-  const weightOf = termWeights(graph, terms);
-  const index = indexFor(graph);
-  const scored = [];
-  for (const node of graph.nodes) {
-    if (node.kind === "file" || node.kind === "external") continue;
-    const { score, why } = scoreNode(node, terms, weightOf);
-    if (score > 0) scored.push({ node, score: round2(score * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
-  }
-  scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
-  const seeds = scored.slice(0, limit);
-  const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget);
-  return { question, matches: seeds, context, tokensEstimate };
-}
-async function queryGraphSemantic(graph, question, options) {
-  const budget = options.budget ?? 2e3;
-  const limit = options.limit ?? 12;
-  const terms = tokenize(question);
-  const weightOf = termWeights(graph, terms);
-  const index = indexFor(graph);
-  const queryVec = await options.embedder.embedQuery(question);
-  const lexRaw = /* @__PURE__ */ new Map();
-  let lexMax = 0;
-  const whyById = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (node.kind === "file" || node.kind === "external") continue;
-    const { score, why } = scoreNode(node, terms, weightOf);
-    lexRaw.set(node.id, score);
-    whyById.set(node.id, why);
-    if (score > lexMax) lexMax = score;
-  }
-  const scored = [];
-  for (const node of graph.nodes) {
-    if (node.kind === "file" || node.kind === "external") continue;
-    const lexNorm = lexMax > 0 ? (lexRaw.get(node.id) ?? 0) / lexMax : 0;
-    const vec = options.nodeVectors.get(node.id);
-    const sem = vec ? Math.max(0, cosine(queryVec, vec)) : 0;
-    const hybrid = 0.5 * lexNorm + 0.5 * sem;
-    if (hybrid <= 0) continue;
-    const lexWhy = whyById.get(node.id);
-    const why = lexWhy || (sem > 0.3 ? `semantic match (${sem.toFixed(2)})` : "weak match");
-    scored.push({ node, score: round2(hybrid * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
-  }
-  scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
-  const seeds = scored.slice(0, limit);
-  const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget);
-  return { question, matches: seeds, context, tokensEstimate };
-}
-function tokenize(q2) {
-  return [
-    ...new Set(
-      q2.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 1 && !STOPWORDS.has(t))
-    )
-  ];
-}
-function scoreNode(node, terms, weightOf = () => 1) {
-  let score = 0;
-  const hits = [];
-  const name = node.name.toLowerCase();
-  const qn = node.qualifiedName.toLowerCase();
-  const file = node.file.toLowerCase();
-  const nameParts = identifierParts(node.name);
-  for (const t of terms) {
-    const w = weightOf(t);
-    if (name === t) {
-      score += 10 * w;
-      hits.push(t);
-    } else if (nameParts.has(t)) {
-      score += 6 * w;
-      hits.push(t);
-    } else if (name.includes(t)) {
-      score += 4 * w;
-      hits.push(t);
-    } else if (qn.includes(t)) {
-      score += 3 * w;
-      hits.push(t);
-    } else if (fuzzyPartMatch(t, nameParts)) {
-      score += 2 * w;
-      hits.push(`~${t}`);
-    } else if (file.includes(t)) {
-      score += 1 * w;
-      hits.push(t);
-    }
-  }
-  return { score, why: hits.length ? `matched: ${hits.join(", ")}` : "" };
-}
-var IMPORTANCE_WEIGHT = 0.4;
-function termWeights(graph, terms) {
-  if (terms.length === 0) return () => 1;
-  const df = /* @__PURE__ */ new Map();
-  let n = 0;
-  for (const node of graph.nodes) {
-    if (node.kind === "file" || node.kind === "external") continue;
-    n++;
-    const name = node.name.toLowerCase();
-    const parts = identifierParts(node.name);
-    for (const t of terms) {
-      if (parts.has(t) || name.includes(t)) df.set(t, (df.get(t) ?? 0) + 1);
-    }
-  }
-  const w = /* @__PURE__ */ new Map();
-  for (const t of terms) {
-    const idf = Math.log((n + 1) / ((df.get(t) ?? 0) + 1)) + 1;
-    w.set(t, Math.max(0.5, Math.min(8, idf)));
-  }
-  return (t) => w.get(t) ?? 1;
-}
-function identifierParts(name) {
-  return new Set(
-    name.split(/[^\p{L}\p{N}]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/u).filter(Boolean).map((s) => s.toLowerCase())
-  );
-}
-function fuzzyPartMatch(term, parts) {
-  for (const part of parts) {
-    const shared = sharedPrefixLen(term, part);
-    if (shared >= 5 && shared >= 0.6 * Math.min(term.length, part.length)) return true;
-  }
-  return false;
-}
-function sharedPrefixLen(a, b) {
-  const n = Math.min(a.length, b.length);
-  let i = 0;
-  while (i < n && a[i] === b[i]) i++;
-  return i;
-}
-function buildContext(graph, index, question, seeds, budget) {
-  const lines = [];
-  lines.push(`# Context for: ${question}`);
-  lines.push("");
-  if (seeds.length === 0) {
-    lines.push("_No matching symbols found in the map. Try different terms, or `vg hubs` for the most important code._");
-    const text2 = lines.join("\n");
-    return { context: text2, tokensEstimate: estimateTokens(text2) };
-  }
-  for (const { node, why } of seeds) {
-    const block = [];
-    block.push(`## ${node.qualifiedName}  (${node.kind}, ${node.file}:${node.span.start})`);
-    if (node.signature) block.push("`" + node.signature + "`");
-    const callees = index.callees(node.id).map((x) => x.node.qualifiedName);
-    const callers = index.callers(node.id).map((x) => x.node.qualifiedName);
-    if (callees.length) block.push(`calls: ${unique(callees).slice(0, 8).join(", ")}`);
-    if (callers.length) block.push(`called by: ${unique(callers).slice(0, 8).join(", ")}`);
-    block.push(`importance ${node.importance.toFixed(3)} \xB7 area #${node.area}${node.isHub ? " \xB7 hub" : ""} \xB7 ${why}`);
-    block.push("");
-    const candidate = lines.concat(block).join("\n");
-    if (estimateTokens(candidate) > budget && lines.length > 2) break;
-    lines.push(...block);
-  }
-  const text = lines.join("\n");
-  return { context: text, tokensEstimate: estimateTokens(text) };
-}
-function unique(xs) {
-  return [...new Set(xs)];
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function round2(x) {
-  return Math.round(x * 1e6) / 1e6;
-}
-
-// src/engine/lookup.ts
-function findNodes(graph, query) {
-  const q2 = query.trim();
-  if (!q2) return [];
-  const byId = graph.nodes.filter((n) => n.id === q2);
-  if (byId.length) return byId;
-  const fileLine = /^(.*):(\d+)$/.exec(q2);
-  if (fileLine) {
-    const file = fileLine[1];
-    const line = Number(fileLine[2]);
-    const spanning = graph.nodes.filter((n) => n.file === file && n.span.start <= line && n.span.end >= line && n.kind !== "file").sort((a, b) => a.span.end - a.span.start - (b.span.end - b.span.start));
-    if (spanning.length) return spanning;
-  }
-  if (/[*?]/.test(q2)) {
-    const re = globToRegExp(q2);
-    return rank(graph.nodes.filter((n) => re.test(n.qualifiedName) || re.test(n.name) || re.test(n.file)));
-  }
-  const byQn = graph.nodes.filter((n) => n.qualifiedName === q2);
-  if (byQn.length) return rank(byQn);
-  const byName = graph.nodes.filter((n) => n.name === q2);
-  if (byName.length) return rank(byName);
-  const lower = q2.toLowerCase();
-  const ci = graph.nodes.filter(
-    (n) => n.qualifiedName.toLowerCase() === lower || n.name.toLowerCase() === lower
-  );
-  if (ci.length) return rank(ci);
-  return rank(graph.nodes.filter((n) => n.qualifiedName.toLowerCase().includes(lower))).slice(0, 25);
-}
-function resolveOne(graph, query, pick) {
-  const candidates = findNodes(graph, query);
-  if (candidates.length === 0) return { candidates };
-  if (pick && pick >= 1 && pick <= candidates.length) return { node: candidates[pick - 1], candidates };
-  if (candidates.length === 1) return { node: candidates[0], candidates };
-  return { candidates };
-}
-function nodeById(graph, id) {
-  return graph.nodes.find((n) => n.id === id);
-}
-function rank(nodes) {
-  return [...nodes].sort(
-    (a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)
-  );
-}
-function globToRegExp(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`, "i");
-}
 function buildGraphologyGraph(nodes, edges) {
   const g = new Graph({ type: "directed", multi: true, allowSelfLoops: true });
   for (const n of nodes) {
@@ -3398,57 +2752,6 @@ function shortestPath(graph, srcId, dstId) {
   if (reverse) return { ids: reverse.slice().reverse(), direction: "reverse" };
   return null;
 }
-
-// src/engine/impact.ts
-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 = indexFor(graph);
-  const root = index.node(rootId);
-  const affected = /* @__PURE__ */ new Map();
-  let minEdgeConfidence = 1;
-  let frontier = [{ id: rootId, conf: 1 }];
-  for (let depth = 1; depth <= maxDepth; depth++) {
-    const nextFrontier = [];
-    for (const { id, conf } of frontier) {
-      for (const e of index.in(id)) {
-        if (!DEPEND_EDGES.has(e.kind)) continue;
-        minEdgeConfidence = Math.min(minEdgeConfidence, e.confidence);
-        const dependentId = e.src;
-        if (dependentId === rootId || affected.has(dependentId)) continue;
-        const node = index.node(dependentId);
-        if (!node) continue;
-        const conf2 = round3(conf * e.confidence * 0.9);
-        affected.set(dependentId, {
-          id: node.id,
-          name: node.qualifiedName,
-          kind: node.kind,
-          file: node.file,
-          line: node.span.start,
-          depth,
-          confidence: conf2
-        });
-        nextFrontier.push({ id: dependentId, conf: conf2 });
-      }
-    }
-    frontier = nextFrontier;
-    if (frontier.length === 0) break;
-  }
-  const items = [...affected.values()].sort(
-    (a, b) => a.depth - b.depth || b.confidence - a.confidence || a.name.localeCompare(b.name)
-  );
-  return {
-    root: { id: rootId, name: root?.qualifiedName ?? rootId },
-    depth: maxDepth,
-    affected: items,
-    direct: items.filter((i) => i.depth === 1).length,
-    transitive: items.filter((i) => i.depth > 1).length,
-    minEdgeConfidence: round3(minEdgeConfidence)
-  };
-}
-function round3(x) {
-  return Math.round(x * 1e6) / 1e6;
-}
 function coveringTests(graph, node, index) {
   const idx = index ?? indexFor(graph);
   const byId = idx.nodeById;
@@ -3484,10 +2787,10 @@ function testsToRun(graph, rootId, depth = 4) {
   };
 }
 function detectRunner(root, lang) {
-  const pkgPath = path17.join(root, "package.json");
-  if (fs17.existsSync(pkgPath)) {
+  const pkgPath = path2.join(root, "package.json");
+  if (fs18.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs18.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() };
@@ -3495,10 +2798,10 @@ function detectRunner(root, lang) {
     } catch {
     }
   }
-  if (lang === "py" || fs17.existsSync(path17.join(root, "pyproject.toml")) || fs17.existsSync(path17.join(root, "pytest.ini"))) {
+  if (lang === "py" || fs18.existsSync(path2.join(root, "pyproject.toml")) || fs18.existsSync(path2.join(root, "pytest.ini"))) {
     return { name: "pytest", command: (f) => `pytest ${f.join(" ")}`.trim() };
   }
-  if (lang === "go" || fs17.existsSync(path17.join(root, "go.mod"))) {
+  if (lang === "go" || fs18.existsSync(path2.join(root, "go.mod"))) {
     return { name: "go test", command: () => "go test ./..." };
   }
   if (lang === "cs" || hasFile(root, /\.csproj$/) || hasFile(root, /\.sln$/)) {
@@ -3507,469 +2810,12 @@ function detectRunner(root, lang) {
   if (lang === "rb") return { name: "rspec", command: (f) => `bundle exec rspec ${f.join(" ")}`.trim() };
   return { name: "tests", command: (f) => f.length ? f.join(" ") : "(no runner detected)" };
 }
-function hasFile(root, re) {
-  try {
-    return fs17.readdirSync(root).some((f) => re.test(f));
-  } catch {
-    return false;
-  }
-}
-var ECOSYSTEMS = ["npm", "pypi", "go", "rust", "ruby", "php", "dotnet", "swift", "dart", "java"];
-function inventory(root) {
-  const manifests = findManifests(root);
-  const records = [];
-  records.push(...npmDeps(manifests.npm));
-  records.push(...pypiDeps(manifests.pypi));
-  records.push(...goDeps(manifests.go));
-  records.push(...cargoDeps(manifests.rust));
-  records.push(...rubyDeps(manifests.ruby));
-  records.push(...phpDeps(manifests.php));
-  records.push(...dotnetDeps(manifests.dotnet));
-  records.push(...swiftDeps(manifests.swift));
-  records.push(...dartDeps(manifests.dart));
-  records.push(...javaDeps(manifests.java));
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = records.filter((r) => {
-    const key = `${r.ecosystem}\0${r.name}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-  deduped.sort((a, b) => a.ecosystem.localeCompare(b.ecosystem) || a.name.localeCompare(b.name));
-  const counts = { total: deduped.length };
-  for (const e of ECOSYSTEMS) counts[e] = 0;
-  for (const r of deduped) counts[r.ecosystem]++;
-  return { records: deduped, counts };
-}
-var SKIP_DIRS2 = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "out",
-  ".vibgrate",
-  "vendor",
-  ".venv",
-  "venv",
-  "env",
-  "__pycache__",
-  "target",
-  ".next",
-  ".nuxt",
-  "coverage",
-  ".cache"
-]);
-var MANIFEST_BY_FILE = {
-  "package.json": "npm",
-  "requirements.txt": "pypi",
-  "pyproject.toml": "pypi",
-  "go.mod": "go",
-  "Cargo.toml": "rust",
-  Gemfile: "ruby",
-  "composer.json": "php",
-  "Package.swift": "swift",
-  "pubspec.yaml": "dart",
-  "pom.xml": "java",
-  "build.gradle": "java",
-  "build.gradle.kts": "java"
-};
-function findManifests(root) {
-  const set = Object.fromEntries(ECOSYSTEMS.map((e) => [e, []]));
-  const MAX_ENTRIES2 = 2e4;
-  let scanned = 0;
-  const walk2 = (dir, depth) => {
-    if (depth > 8 || scanned > MAX_ENTRIES2) return;
-    let entries;
-    try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      scanned++;
-      if (scanned > MAX_ENTRIES2) break;
-      if (e.isDirectory()) {
-        if (!SKIP_DIRS2.has(e.name) && !e.name.startsWith(".")) walk2(path17.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(path17.join(dir, e.name));
-    }
-  };
-  walk2(root, 0);
-  for (const e of ECOSYSTEMS) set[e].sort();
-  return set;
-}
-function npmDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let pkg;
-    try {
-      pkg = JSON.parse(fs17.readFileSync(file, "utf8"));
-    } catch {
-      continue;
-    }
-    const dir = path17.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) });
-    }
-  }
-  return out;
-}
-function installedNpmVersion(dir, name) {
-  let cur = dir;
-  for (let i = 0; i < 12; i++) {
-    const p = path17.join(cur, "node_modules", name, "package.json");
-    try {
-      return JSON.parse(fs17.readFileSync(p, "utf8")).version;
-    } catch {
-    }
-    const parent = path17.dirname(cur);
-    if (parent === cur) break;
-    cur = parent;
-  }
-  return void 0;
-}
-function installedTreeVersion(root, ecosystem, name) {
-  if (ecosystem === "pypi") return installedPypiVersion(root, name);
-  if (ecosystem === "php") return installedPhpVersion(root, name);
-  return void 0;
-}
-function normalizePep503(name) {
-  return name.trim().toLowerCase().replace(/[-_.]+/g, "-");
-}
-function sitePackagesDirs(base) {
-  const out = [];
-  try {
-    for (const d of fs17.readdirSync(path17.join(base, "lib"))) {
-      if (d.startsWith("python")) out.push(path17.join(base, "lib", d, "site-packages"));
-    }
-  } catch {
-  }
-  out.push(path17.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(path17.join(root, venv))) {
-      let entries;
-      try {
-        entries = fs17.readdirSync(sp);
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        const m = /^(.+?)-(\d[^-]*)\.dist-info$/.exec(entry);
-        if (m && normalizePep503(m[1]) === target) return m[2];
-      }
-    }
-  }
-  return void 0;
-}
-function installedPhpVersion(root, name) {
-  let data;
-  try {
-    data = JSON.parse(fs17.readFileSync(path17.join(root, "vendor", "composer", "installed.json"), "utf8"));
-  } catch {
-    return void 0;
-  }
-  const pkgs = Array.isArray(data) ? data : data.packages;
-  if (!Array.isArray(pkgs)) return void 0;
-  const p = pkgs.find((x) => x && typeof x === "object" && x.name === name);
-  return typeof p?.version === "string" ? p.version.replace(/^v/, "") : void 0;
-}
-function pypiDeps(files) {
-  const byName = /* @__PURE__ */ new Map();
-  const add3 = (name, declared) => {
-    const clean = name.trim().replace(/\[.*\]$/, "");
-    if (!clean || clean.toLowerCase() === "python") return;
-    if (!byName.has(clean)) byName.set(clean, { name: clean, ecosystem: "pypi", declared: declared.trim() || "*" });
-  };
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    if (path17.basename(file) === "requirements.txt") {
-      for (const line of text.split("\n")) {
-        const t = line.trim();
-        if (!t || t.startsWith("#") || t.startsWith("-")) continue;
-        const m = /^([A-Za-z0-9._-]+(?:\[[^\]]*\])?)\s*([<>=!~).*]+.*)?$/.exec(t);
-        if (m) add3(m[1], m[2] ?? "*");
-      }
-    } else {
-      for (const dep of pep621Dependencies(text)) {
-        const m = /^([A-Za-z0-9._-]+(?:\[[^\]]*\])?)\s*(.*)$/.exec(dep.trim());
-        if (m) add3(m[1], m[2] ?? "*");
-      }
-      for (const [name, spec] of poetryDependencies(text)) add3(name, spec);
-    }
-  }
-  return [...byName.values()];
-}
-function pep621Dependencies(text) {
-  const section = sectionBody(text, "project");
-  if (!section) return [];
-  const start = /dependencies\s*=\s*\[/.exec(section);
-  if (!start) return [];
-  let depth = 0;
-  let inStr = false;
-  let strCh = "";
-  const out = [];
-  let cur = "";
-  for (let i = start.index + start[0].length - 1; i < section.length; i++) {
-    const ch = section[i];
-    if (inStr) {
-      if (ch === strCh) {
-        out.push(cur);
-        inStr = false;
-      } else cur += ch;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      inStr = true;
-      strCh = ch;
-      cur = "";
-    } else if (ch === "[") depth++;
-    else if (ch === "]") {
-      depth--;
-      if (depth === 0) break;
-    }
-  }
-  return out;
-}
-function poetryDependencies(text) {
-  const out = [];
-  const lines = text.split("\n");
-  let inDeps = false;
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (line.startsWith("[")) {
-      inDeps = /^\[tool\.poetry(\.group\.[^.\]]+)?\.dependencies\]$/.test(line);
-      continue;
-    }
-    if (!inDeps || !line || line.startsWith("#")) continue;
-    const m = /^([A-Za-z0-9._-]+)\s*=\s*["']([^"']*)["']/.exec(line);
-    if (m) out.push([m[1], m[2] || "*"]);
-  }
-  return out;
-}
-function sectionBody(text, name) {
-  const lines = text.split("\n");
-  let capturing = false;
-  const body = [];
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (/^\[/.test(line)) {
-      if (capturing) break;
-      capturing = line === `[${name}]`;
-      continue;
-    }
-    if (capturing) body.push(raw);
-  }
-  return capturing || body.length ? body.join("\n") : null;
-}
-function goDeps(files) {
-  const out = [];
-  for (const mod of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(mod, "utf8");
-    } catch {
-      continue;
-    }
-    const re = /^\s*(?:require\s+)?([\w./-]+)\s+v(\S+)/gm;
-    let m;
-    while (m = re.exec(text)) {
-      if (m[1] === "go" || m[1] === "require" || m[1].startsWith("module")) continue;
-      out.push({ name: m[1], ecosystem: "go", declared: `v${m[2]}` });
-    }
-  }
-  return out;
-}
-function cargoDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    for (const table of ["dependencies", "dev-dependencies", "build-dependencies"]) {
-      const body = sectionBody(text, table);
-      if (!body) continue;
-      for (const raw of body.split("\n")) {
-        const line = raw.trim();
-        if (!line || line.startsWith("#")) continue;
-        const m = /^([A-Za-z0-9._-]+)\s*=\s*(.+)$/.exec(line);
-        if (!m) continue;
-        const rhs = m[2].trim();
-        let declared = "*";
-        if (rhs.startsWith('"')) {
-          const sm = /^"([^"]+)"/.exec(rhs);
-          if (sm) declared = sm[1];
-        } else if (rhs.startsWith("{")) {
-          const vm = /version\s*=\s*"([^"]+)"/.exec(rhs);
-          if (vm) declared = vm[1];
-        }
-        out.push({ name: m[1], ecosystem: "rust", declared });
-      }
-    }
-  }
-  return out;
-}
-function rubyDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    const re = /^\s*gem\s+["']([^"']+)["']\s*(?:,\s*["']([^"']+)["'])?/gm;
-    let m;
-    while (m = re.exec(text)) out.push({ name: m[1], ecosystem: "ruby", declared: m[2] ?? "*" });
-  }
-  return out;
-}
-function phpDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let pkg;
-    try {
-      pkg = JSON.parse(fs17.readFileSync(file, "utf8"));
-    } catch {
-      continue;
-    }
-    const all = { ...pkg.require, ...pkg["require-dev"] };
-    for (const [name, declared] of Object.entries(all)) {
-      if (!name.includes("/")) continue;
-      out.push({ name, ecosystem: "php", declared });
-    }
-  }
-  return out;
-}
-function dotnetDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    const tagRe = /<PackageReference\b[^>]*>/gi;
-    let m;
-    while (m = tagRe.exec(text)) {
-      const inc = /Include\s*=\s*"([^"]+)"/i.exec(m[0]);
-      if (!inc) continue;
-      const ver = /Version\s*=\s*"([^"]+)"/i.exec(m[0]);
-      out.push({ name: inc[1], ecosystem: "dotnet", declared: ver?.[1] ?? "*" });
-    }
-  }
-  return out;
-}
-function swiftDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    const re = /\.package\(/g;
-    let m;
-    while (m = re.exec(text)) {
-      const win = text.slice(m.index, m.index + 200);
-      const urlM = /url:\s*"([^"]+)"/.exec(win);
-      if (!urlM) continue;
-      const name = (urlM[1].replace(/\.git$/, "").split("/").filter(Boolean).pop() ?? urlM[1]).toLowerCase();
-      const verM = /"(\d+\.\d+(?:\.\d+)?)"/.exec(win.slice(urlM.index + urlM[0].length));
-      out.push({ name, ecosystem: "swift", declared: verM?.[1] ?? "*" });
-    }
-  }
-  return out;
-}
-function dartDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    let section = "";
-    for (const raw of text.split("\n")) {
-      const top = /^([a-z_]+):\s*$/.exec(raw);
-      if (top) {
-        section = top[1];
-        continue;
-      }
-      if (section !== "dependencies" && section !== "dev_dependencies") continue;
-      const m = /^  ([A-Za-z0-9_.]+):\s*(\S.*)?$/.exec(raw);
-      if (!m || m[1] === "flutter" || m[1] === "sdk") continue;
-      const declared = (m[2] ?? "").replace(/^["']|["']$/g, "").trim() || "*";
-      out.push({ name: m[1], ecosystem: "dart", declared });
-    }
-  }
-  return out;
-}
-function javaDeps(files) {
-  const out = [];
-  for (const file of files) {
-    let text;
-    try {
-      text = fs17.readFileSync(file, "utf8");
-    } catch {
-      continue;
-    }
-    if (path17.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);
-        if (!g || !a) continue;
-        const v = /<version>([^<]+)<\/version>/.exec(block);
-        const declared = v ? v[1].trim().startsWith("${") ? "*" : v[1].trim() : "*";
-        out.push({ name: `${g[1].trim()}:${a[1].trim()}`, ecosystem: "java", declared });
-      }
-    } else {
-      const re = /(?:implementation|api|compileOnly|runtimeOnly|testImplementation|testRuntimeOnly|annotationProcessor)\s*[(]?\s*["']([\w.-]+):([\w.-]+):([^"']+)["']/g;
-      let m;
-      while (m = re.exec(text)) out.push({ name: `${m[1]}:${m[2]}`, ecosystem: "java", declared: m[3] });
-    }
-  }
-  return out;
-}
-async function enrichOnline(records, fetchImpl = globalThis.fetch) {
-  for (const r of records) {
-    if (r.ecosystem !== "npm" || !r.installed) continue;
-    try {
-      const res = await fetchImpl(`https://registry.npmjs.org/${encodeURIComponent(r.name)}/latest`);
-      if (!res.ok) continue;
-      const data = await res.json();
-      r.latest = data.version;
-      r.drift = classify(r.installed, r.latest);
-    } catch {
-      r.drift = "unknown";
-    }
-  }
-}
-function classify(installed, latest) {
-  if (!latest) return "unknown";
-  const a = installed.split(".").map(Number);
-  const b = latest.split(".").map(Number);
-  if (a[0] !== b[0]) return "major";
-  if (a[1] !== b[1]) return "minor";
-  if (a[2] !== b[2]) return "patch";
-  return "current";
+function hasFile(root, re) {
+  try {
+    return fs18.readdirSync(root).some((f) => re.test(f));
+  } catch {
+    return false;
+  }
 }
 function discoverModels(home = os.homedir()) {
   return [...ollama(home), ...lmStudio(home), ...looseGguf(home)].sort(
@@ -3977,10 +2823,10 @@ function discoverModels(home = os.homedir()) {
   );
 }
 function ollama(home) {
-  const base = path17.join(home, ".ollama", "models", "manifests");
+  const base = path2.join(home, ".ollama", "models", "manifests");
   const out = [];
   walk(base, 4, (file) => {
-    const rel2 = path17.relative(base, file).split(path17.sep);
+    const rel2 = path2.relative(base, file).split(path2.sep);
     if (rel2.length >= 2) {
       const tag = rel2[rel2.length - 1];
       const model = rel2[rel2.length - 2];
@@ -3990,24 +2836,24 @@ function ollama(home) {
   return dedupe(out);
 }
 function lmStudio(home) {
-  const bases = [path17.join(home, ".lmstudio", "models"), path17.join(home, ".cache", "lm-studio", "models")];
+  const bases = [path2.join(home, ".lmstudio", "models"), path2.join(home, ".cache", "lm-studio", "models")];
   const out = [];
   for (const base of bases) {
     walk(base, 5, (file) => {
       if (!file.endsWith(".gguf")) return;
-      const rel2 = path17.relative(base, file).replace(/\\/g, "/");
+      const rel2 = path2.relative(base, file).replace(/\\/g, "/");
       out.push({ runtime: "lm-studio", name: rel2, path: file });
     });
   }
   return dedupe(out);
 }
 function looseGguf(home) {
-  const bases = [path17.join(home, "models"), path17.join(home, ".cache", "huggingface")];
+  const bases = [path2.join(home, "models"), path2.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: path17.basename(file), path: file });
+      out.push({ runtime: "gguf", name: path2.basename(file), path: file });
     });
   }
   return dedupe(out);
@@ -4016,12 +2862,12 @@ function walk(dir, depth, onFile) {
   if (depth < 0) return;
   let entries;
   try {
-    entries = fs17.readdirSync(dir, { withFileTypes: true });
+    entries = fs18.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const abs = path17.join(dir, e.name);
+    const abs = path2.join(dir, e.name);
     if (e.isDirectory()) walk(abs, depth - 1, onFile);
     else if (e.isFile()) onFile(abs);
   }
@@ -4037,457 +2883,11 @@ function dedupe(models) {
   }
   return out;
 }
-function lockfileVersion(root, ecosystem, name) {
-  if (ecosystem === "npm") return packageLockVersion(root, name) ?? yarnLockVersion(root, name);
-  if (ecosystem === "pypi") return pypiLockVersion(root, name);
-  if (ecosystem === "rust") return tomlPackageLock(root, "Cargo.lock", name, rustName);
-  if (ecosystem === "ruby") return gemfileLock(root, name);
-  if (ecosystem === "php") return composerLock(root, name);
-  if (ecosystem === "dotnet") return packagesLock(root, name);
-  if (ecosystem === "swift") return packageResolved(root, name);
-  if (ecosystem === "dart") return pubspecLock(root, name);
-  if (ecosystem === "java") return gradleLock(root, name);
-  return void 0;
-}
-function gradleLock(root, name) {
-  let text;
-  try {
-    text = fs17.readFileSync(path17.join(root, "gradle.lockfile"), "utf8");
-  } catch {
-    return void 0;
-  }
-  const m = new RegExp(`^${escapeRegExp(name)}:([^=\\s]+)=`, "m").exec(text);
-  return m ? m[1] : void 0;
-}
-function packageResolved(root, name) {
-  let data;
-  try {
-    data = JSON.parse(fs17.readFileSync(path17.join(root, "Package.resolved"), "utf8"));
-  } catch {
-    return void 0;
-  }
-  const pins = data.pins ?? data.object?.pins;
-  if (!Array.isArray(pins)) return void 0;
-  const target = name.toLowerCase();
-  for (const p of pins) {
-    const id = (p.identity ?? p.package ?? "").toLowerCase();
-    if (id === target && p.state?.version) return p.state.version;
-  }
-  return void 0;
-}
-function pubspecLock(root, name) {
-  let text;
-  try {
-    text = fs17.readFileSync(path17.join(root, "pubspec.lock"), "utf8");
-  } catch {
-    return void 0;
-  }
-  let inPkg = false;
-  for (const line of text.split("\n")) {
-    const key = /^  ([A-Za-z0-9_.]+):\s*$/.exec(line);
-    if (key) {
-      inPkg = key[1] === name;
-      continue;
-    }
-    if (inPkg) {
-      const vm = /^\s+version:\s*"?([^"\s]+)"?/.exec(line);
-      if (vm) return vm[1];
-    }
-  }
-  return void 0;
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function gemfileLock(root, name) {
-  let text;
-  try {
-    text = fs17.readFileSync(path17.join(root, "Gemfile.lock"), "utf8");
-  } catch {
-    return void 0;
-  }
-  const m = new RegExp(`^    ${escapeRegExp(name)} \\((\\d[^)]*)\\)`, "m").exec(text);
-  return m ? m[1] : void 0;
-}
-function composerLock(root, name) {
-  let data;
-  try {
-    data = JSON.parse(fs17.readFileSync(path17.join(root, "composer.lock"), "utf8"));
-  } catch {
-    return void 0;
-  }
-  for (const section of ["packages", "packages-dev"]) {
-    const arr = data[section];
-    if (!Array.isArray(arr)) continue;
-    const p = arr.find((x) => x && x.name === name);
-    if (p && typeof p.version === "string") return p.version.replace(/^v/, "");
-  }
-  return void 0;
-}
-function packagesLock(root, name) {
-  let data;
-  try {
-    data = JSON.parse(fs17.readFileSync(path17.join(root, "packages.lock.json"), "utf8"));
-  } catch {
-    return void 0;
-  }
-  const target = name.toLowerCase();
-  for (const fw of Object.values(data.dependencies ?? {})) {
-    if (!fw || typeof fw !== "object") continue;
-    for (const [id, v] of Object.entries(fw)) {
-      if (id.toLowerCase() === target && v && typeof v.resolved === "string") return v.resolved;
-    }
-  }
-  return void 0;
-}
-function pep503(name) {
-  return name.trim().toLowerCase().replace(/[-_.]+/g, "-");
-}
-function rustName(name) {
-  return name.trim().toLowerCase();
-}
-function pypiLockVersion(root, name) {
-  return tomlPackageLock(root, "poetry.lock", name, pep503) ?? tomlPackageLock(root, "uv.lock", name, pep503) ?? pipfileLock(root, name);
-}
-function tomlPackageLock(root, file, name, normalize3) {
-  let text;
-  try {
-    text = fs17.readFileSync(path17.join(root, file), "utf8");
-  } catch {
-    return void 0;
-  }
-  const target = normalize3(name);
-  for (const block of text.split(/\[\[package\]\]/)) {
-    const nm = /(?:^|\n)\s*name\s*=\s*"([^"]+)"/.exec(block);
-    if (nm && normalize3(nm[1]) === target) {
-      const ver = /(?:^|\n)\s*version\s*=\s*"([^"]+)"/.exec(block);
-      if (ver) return ver[1];
-    }
-  }
-  return void 0;
-}
-function pipfileLock(root, name) {
-  let data;
-  try {
-    data = JSON.parse(fs17.readFileSync(path17.join(root, "Pipfile.lock"), "utf8"));
-  } catch {
-    return void 0;
-  }
-  const target = pep503(name);
-  for (const section of ["default", "develop"]) {
-    const deps = data[section];
-    if (!deps || typeof deps !== "object") continue;
-    for (const [k, v] of Object.entries(deps)) {
-      if (pep503(k) === target && v && typeof v.version === "string") {
-        return v.version.replace(/^==/, "");
-      }
-    }
-  }
-  return void 0;
-}
-function packageLockVersion(root, name) {
-  let data;
-  try {
-    data = JSON.parse(fs17.readFileSync(path17.join(root, "package-lock.json"), "utf8"));
-  } catch {
-    return void 0;
-  }
-  const top = data.packages?.[`node_modules/${name}`]?.version;
-  if (typeof top === "string") return top;
-  const v1 = data.dependencies?.[name]?.version;
-  return typeof v1 === "string" ? v1 : void 0;
-}
-function yarnLockVersion(root, name) {
-  let text;
-  try {
-    text = fs17.readFileSync(path17.join(root, "yarn.lock"), "utf8");
-  } catch {
-    return void 0;
-  }
-  let inBlock = false;
-  for (const line of text.split("\n")) {
-    if (line && !/^\s/.test(line) && !line.startsWith("#")) {
-      inBlock = headerNamesPackage(line, name);
-    } else if (inBlock) {
-      const m = /^\s+version:?\s+"?([^"\s]+)"?/.exec(line);
-      if (m) return m[1];
-    }
-  }
-  return void 0;
-}
-function headerNamesPackage(header, name) {
-  return header.replace(/:\s*$/, "").split(",").some((spec) => {
-    const s = spec.trim().replace(/^"|"$/g, "");
-    const at = s.lastIndexOf("@");
-    if (at <= 0) return false;
-    const specName = s.slice(0, at);
-    return specName === name;
-  });
-}
-
-// src/engine/lib.ts
-var LIB_SCHEMA = "vg-lib/1.0";
-function catalogPath(root) {
-  return path17.join(root, "vibgrate.lib.json");
-}
-function libDir(root) {
-  return path17.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 (fs17.existsSync(file)) {
-    try {
-      const data = JSON.parse(fs17.readFileSync(file, "utf8"));
-      if (data.schemaVersion === LIB_SCHEMA && data.libraries) return data;
-    } catch {
-    }
-  }
-  return { schemaVersion: LIB_SCHEMA, libraries: {} };
-}
-function saveCatalog(root, catalog) {
-  fs17.writeFileSync(catalogPath(root), `${stableStringify(catalog, 2)}
-`);
-}
-function resolveLib(catalog, name) {
-  const id = libId(name);
-  if (catalog.libraries[id]) return catalog.libraries[id];
-  const lower = name.toLowerCase();
-  const all = Object.values(catalog.libraries);
-  return all.find((e) => e.name.toLowerCase() === lower) ?? all.find((e) => e.id.includes(id) || e.name.toLowerCase().includes(lower));
-}
-function installedVersion(root, name) {
-  const rec = inventory(root).records.find((r) => r.name === name);
-  return rec?.installed ?? rec?.declared;
-}
-var stripRange = (v) => v?.replace(/^[v^~>=<\s]+/, "");
-function resolveVersion(root, name) {
-  const rec = inventory(root).records.find((r) => r.name === name);
-  const declared = rec?.declared;
-  const installed = rec?.installed ?? (rec ? installedTreeVersion(root, rec.ecosystem, name) : void 0);
-  const lockfile = rec ? lockfileVersion(root, rec.ecosystem, name) : void 0;
-  let mismatch;
-  if (lockfile && installed && stripRange(lockfile) !== stripRange(installed)) {
-    mismatch = {
-      lockfile,
-      installed,
-      note: `lockfile pins ${lockfile} but the installed tree has ${installed} \u2014 your install is out of sync with the lockfile (re-install or commit the lock)`
-    };
-  }
-  const served = lockfile ?? installed ?? declared;
-  const source = lockfile ? "lockfile" : installed ? "installed" : declared ? "declared" : "unknown";
-  return { served, source, lockfile, installed, declared, mismatch };
-}
-function driftFor(root, entry) {
-  const installed = installedVersion(root, entry.name);
-  if (!installed || entry.version === "*") return { cataloged: entry.version, installed, drift: "unknown" };
-  const norm = (v) => v.replace(/^[v^~>=<\s]+/, "");
-  const a = norm(entry.version);
-  const b = norm(installed);
-  if (a === b) return { cataloged: entry.version, installed, drift: "current" };
-  return { cataloged: entry.version, installed, drift: cmp(a, b) < 0 ? "behind" : "ahead" };
-}
-function cmp(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const d = (pa[i] || 0) - (pb[i] || 0);
-    if (d) return d;
-  }
-  return 0;
-}
-function parseGitSource(source) {
-  if (source.startsWith("git+")) return source.slice(4);
-  if (/^git@[^:]+:/.test(source)) return source;
-  if (/\.git\/?$/.test(source)) return source;
-  return null;
-}
-async function addLibrary(source, opts) {
-  const { root } = opts;
-  let content;
-  let type = "local";
-  const gitUrl = parseGitSource(source);
-  if (gitUrl) {
-    if (!opts.allowNetwork) {
-      throw new Error(`refusing to clone ${source} without --online (offline by default)`);
-    }
-    content = cloneAndReadGit(gitUrl);
-    type = "git";
-  } else if (/^https?:\/\//.test(source)) {
-    if (!opts.allowNetwork) {
-      throw new Error(`refusing to fetch ${source} without --online (offline by default)`);
-    }
-    const res = await (opts.fetchImpl ?? globalThis.fetch)(source);
-    if (!res.ok) throw new Error(`fetch failed (${res.status}) for ${source}`);
-    content = await res.text();
-    type = source.endsWith("llms.txt") ? "llms.txt" : source.endsWith(".json") ? "openapi" : "website";
-  } else {
-    const abs = path17.resolve(root, source);
-    if (!fs17.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) ?? "*";
-  fs17.mkdirSync(libDir(root), { recursive: true });
-  const docFileAbs = path17.join(libDir(root), `${id}.md`);
-  fs17.writeFileSync(docFileAbs, content);
-  const entry = {
-    id,
-    name,
-    version,
-    source: { type, location: source },
-    docFile: path17.relative(root, docFileAbs).split(path17.sep).join("/"),
-    docHash: hashString(content),
-    bytes: Buffer.byteLength(content, "utf8")
-  };
-  const catalog = loadCatalog(root);
-  catalog.libraries[id] = entry;
-  saveCatalog(root, catalog);
-  return entry;
-}
-function readDoc(root, entry) {
-  const abs = path17.resolve(root, entry.docFile);
-  return fs17.existsSync(abs) ? fs17.readFileSync(abs, "utf8") : "";
-}
-function npmPackageDir(root, name) {
-  let cur = root;
-  for (let i = 0; i < 12; i++) {
-    const dir = path17.join(cur, "node_modules", name);
-    if (fs17.existsSync(path17.join(dir, "package.json"))) return dir;
-    const parent = path17.dirname(cur);
-    if (parent === cur) break;
-    cur = parent;
-  }
-  return void 0;
-}
-function localPackageDocs(root, name) {
-  const dir = npmPackageDir(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 = path17.join(dir, f);
-    try {
-      const docs = fs17.readFileSync(p, "utf8");
-      if (docs.trim()) {
-        return { docs, version, source: path17.relative(root, p).split(path17.sep).join("/") };
-      }
-    } catch {
-    }
-  }
-  try {
-    const pkg = JSON.parse(fs17.readFileSync(path17.join(dir, "package.json"), "utf8"));
-    if (pkg.description?.trim()) {
-      return {
-        docs: `# ${name}
-
-${pkg.description}`,
-        version: version ?? pkg.version,
-        source: path17.relative(root, path17.join(dir, "package.json")).split(path17.sep).join("/")
-      };
-    }
-  } catch {
-  }
-  return void 0;
-}
-function dtsEntry(dir) {
-  try {
-    const pkg = JSON.parse(fs17.readFileSync(path17.join(dir, "package.json"), "utf8"));
-    const rel2 = pkg.types ?? pkg.typings;
-    if (typeof rel2 === "string") {
-      const p = path17.join(dir, rel2);
-      if (fs17.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 = path17.join(dir, c);
-    if (fs17.existsSync(p)) return p;
-  }
-  return void 0;
-}
-function extractDtsApi(src, maxDecls = 200) {
-  const out = [];
-  let depth = 0;
-  let capture = null;
-  for (const raw of src.split("\n")) {
-    const line = raw.trim();
-    if (capture === null && depth === 0 && /^export\b/.test(line) && !/^export\s+(\{|\*|default\b|type\s+\{)/.test(line)) {
-      capture = [];
-    }
-    if (capture) capture.push(raw);
-    for (const ch of raw) {
-      if (ch === "{") depth++;
-      else if (ch === "}") depth = Math.max(0, depth - 1);
-    }
-    if (capture && depth === 0 && /[;}]\s*$/.test(line)) {
-      out.push(capture.join("\n").trim());
-      capture = null;
-      if (out.length >= maxDecls) break;
-    }
-  }
-  return out;
-}
-function localApiSurface(root, name) {
-  const dir = npmPackageDir(root, name);
-  if (!dir) return void 0;
-  const dts = dtsEntry(dir);
-  if (!dts) return void 0;
-  let src;
-  try {
-    src = fs17.readFileSync(dts, "utf8");
-  } catch {
-    return void 0;
-  }
-  const decls = extractDtsApi(src);
-  return decls.length ? decls.join("\n\n") : void 0;
-}
-function cloneAndReadGit(url) {
-  const dir = fs17.mkdtempSync(path17.join(os.tmpdir(), "vg-lib-git-"));
-  try {
-    execFileSync("git", ["clone", "--depth", "1", "--quiet", url, dir], {
-      stdio: ["ignore", "ignore", "pipe"]
-    });
-  } catch (err) {
-    fs17.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 {
-    fs17.rmSync(dir, { recursive: true, force: true });
-  }
-}
-function readGitDocs(dir) {
-  const docsDir = path17.join(dir, "docs");
-  if (fs17.existsSync(docsDir) && fs17.statSync(docsDir).isDirectory()) return readLocal(docsDir);
-  const readme = ["README.md", "README.mdx", "README.txt", "README.rst", "readme.md"].map((f) => path17.join(dir, f)).find((p) => fs17.existsSync(p));
-  if (readme) return fs17.readFileSync(readme, "utf8");
-  return readLocal(dir);
-}
-function readLocal(abs) {
-  const stat = fs17.statSync(abs);
-  if (stat.isFile()) return fs17.readFileSync(abs, "utf8");
-  const parts = [];
-  const files = fs17.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} -->
-${fs17.readFileSync(path17.join(abs, f), "utf8")}`);
-  return parts.join("\n\n");
-}
-function inferName(source) {
-  const cleaned = source.replace(/^git\+/, "").replace(/\.git\/?$/i, "");
-  const base = cleaned.replace(/\/+$/, "").split(/[/:]/).pop() ?? cleaned;
-  return base.replace(/\.(md|mdx|txt|rst|json)$/i, "").replace(/^llms$/, "docs");
-}
 function findGitRoot(startDir = process.cwd()) {
-  let dir = path17.resolve(startDir);
+  let dir = path2.resolve(startDir);
   for (; ; ) {
-    if (fs17.existsSync(path17.join(dir, ".git"))) return dir;
-    const parent = path17.dirname(dir);
+    if (fs18.existsSync(path2.join(dir, ".git"))) return dir;
+    const parent = path2.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -4498,19 +2898,19 @@ function normalizeEntry(line) {
 function ensureGitignored(entry, startDir = process.cwd()) {
   const root = findGitRoot(startDir);
   if (!root) return { status: "not-a-repo", entry };
-  const gitignorePath = path17.join(root, ".gitignore");
+  const gitignorePath = path2.join(root, ".gitignore");
   const target = normalizeEntry(entry);
   let existing = "";
   let fileExisted = true;
   try {
-    existing = fs17.readFileSync(gitignorePath, "utf8");
+    existing = fs18.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");
-  fs17.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
+  fs18.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
 `, "utf8");
   return { status: fileExisted ? "added" : "created", entry, gitignorePath };
 }
@@ -4664,14 +3064,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 = path17.resolve(opts.write);
+    const writePath = path2.resolve(opts.write);
     await writeTextFile(writePath, dsn + "\n");
     console.log("");
     console.log(chalk.green("\u2714") + ` DSN written to ${opts.write}`);
-    const root = findGitRoot(path17.dirname(writePath));
-    const rel2 = root ? path17.relative(root, writePath).split(path17.sep).join("/") : "";
+    const root = findGitRoot(path2.dirname(writePath));
+    const rel2 = root ? path2.relative(root, writePath).split(path2.sep).join("/") : "";
     if (root && rel2 && !rel2.startsWith("..")) {
-      const res = ensureGitignored(rel2, path17.dirname(writePath));
+      const res = ensureGitignored(rel2, path2.dirname(writePath));
       if (res.status === "created") {
         console.log(chalk.green("\u2714") + ` Created .gitignore and ignored ${rel2}`);
       } else if (res.status === "added") {
@@ -4689,30 +3089,30 @@ dsnCommand.command("create").description("Create a new DSN token").option("--ing
 var STORE_DIRNAME = ".vibgrate";
 var STORE_FILENAME = "credentials.json";
 function homeCredentialsPath() {
-  return path17.join(os.homedir(), STORE_DIRNAME, STORE_FILENAME);
+  return path2.join(os.homedir(), STORE_DIRNAME, STORE_FILENAME);
 }
 function projectCredentialsPath(cwd = process.cwd()) {
   const root = findGitRoot(cwd) ?? cwd;
-  return path17.join(root, STORE_DIRNAME, STORE_FILENAME);
+  return path2.join(root, STORE_DIRNAME, STORE_FILENAME);
 }
 function credentialsPath(opts = {}) {
   const override = process.env.VIBGRATE_CREDENTIALS?.trim();
-  if (override) return path17.resolve(override);
+  if (override) return path2.resolve(override);
   const local = projectCredentialsPath(opts.cwd);
   if (opts.local) return local;
-  if (fs17.existsSync(local)) return local;
+  if (fs18.existsSync(local)) return local;
   return homeCredentialsPath();
 }
 function gitignoreEntryForCredentials(repoRoot, credsFile = credentialsPath()) {
-  const rel2 = path17.relative(repoRoot, credsFile);
-  if (rel2 && !rel2.startsWith("..") && !path17.isAbsolute(rel2)) {
-    return rel2.split(path17.sep).join("/");
+  const rel2 = path2.relative(repoRoot, credsFile);
+  if (rel2 && !rel2.startsWith("..") && !path2.isAbsolute(rel2)) {
+    return rel2.split(path2.sep).join("/");
   }
   return `${STORE_DIRNAME}/${STORE_FILENAME}`;
 }
 function readStoredCredentials(opts = {}) {
   try {
-    const raw = fs17.readFileSync(credentialsPath(opts), "utf8");
+    const raw = fs18.readFileSync(credentialsPath(opts), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed.dsn === "string" && parsed.dsn ? parsed : null;
   } catch {
@@ -4721,16 +3121,16 @@ function readStoredCredentials(opts = {}) {
 }
 function writeStoredCredentials(creds, opts = {}) {
   const file = credentialsPath(opts);
-  fs17.mkdirSync(path17.dirname(file), { recursive: true });
-  fs17.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  fs18.mkdirSync(path2.dirname(file), { recursive: true });
+  fs18.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
   try {
-    fs17.chmodSync(file, 384);
+    fs18.chmodSync(file, 384);
   } catch {
   }
 }
 function clearStoredCredentials(opts = {}) {
   try {
-    fs17.rmSync(credentialsPath(opts));
+    fs18.rmSync(credentialsPath(opts));
     return true;
   } catch {
     return false;
@@ -5101,7 +3501,7 @@ var pushCommand = new Command("push").description("Push scan results to Vibgrate
     if (opts.strict) process.exit(1);
     return;
   }
-  const filePath = path17.resolve(opts.file);
+  const filePath = path2.resolve(opts.file);
   if (!await pathExists(filePath)) {
     console.error(chalk.red(`Scan artifact not found: ${filePath}`));
     console.error(chalk.dim('Run "vibgrate scan" first.'));
@@ -5164,8 +3564,8 @@ var pushCommand = new Command("push").description("Push scan results to Vibgrate
 });
 function readScanArtifact(root) {
   try {
-    const file = path17.join(root, ".vibgrate", "scan_result.json");
-    return JSON.parse(fs17.readFileSync(file, "utf8"));
+    const file = path2.join(root, ".vibgrate", "scan_result.json");
+    return JSON.parse(fs18.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -5270,7 +3670,7 @@ var DEFAULT_SELECTION_WEIGHTS = {
 };
 
 // src/engine/select.ts
-var STOPWORDS2 = /* @__PURE__ */ new Set(["the", "a", "an", "to", "of", "in", "for", "and", "or", "is", "how", "do", "i", "use", "using", "with", "on", "my"]);
+var STOPWORDS = /* @__PURE__ */ new Set(["the", "a", "an", "to", "of", "in", "for", "and", "or", "is", "how", "do", "i", "use", "using", "with", "on", "my"]);
 var USAGE_RE = /\b(usage|example|examples|quick ?start|getting started|api|guide|how to|reference|tutorial|basic)\b/i;
 var PREAMBLE_RE = /\b(install|installation|license|licence|contributing|contributors?|sponsors?|table of contents|toc|changelog|funding|code of conduct|security|acknowledge)\b/i;
 function splitSections(md) {
@@ -5317,9 +3717,9 @@ function chunkBody(body) {
 function stripNoise(body) {
   return body.split("\n").filter((l) => !/^\s*(?:!\[[^\]]*\]\([^)]*\)\s*)+$/.test(l)).join("\n").trim();
 }
-function tokenizeQuery(q2) {
-  if (!q2) return [];
-  return [...new Set(q2.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1 && !STOPWORDS2.has(w)))];
+function tokenizeQuery(q) {
+  if (!q) return [];
+  return [...new Set(q.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1 && !STOPWORDS.has(w)))];
 }
 function symbolsFromApi(api) {
   if (!api) return [];
@@ -5551,11 +3951,11 @@ async function publishPrivateLibrary(req, opts = {}) {
 }
 
 // src/engine/hosted-cache.ts
-var CACHE_VERSION2 = "vg-hosted-docs/1";
+var CACHE_VERSION = "vg-hosted-docs/1";
 var HOSTED_DOCS_TTL_MS = 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES = 64;
-function cachePath2(root) {
-  return path17.join(cacheDir(root), "hosted-docs.json");
+function cachePath(root) {
+  return path2.join(cacheDir(root), "hosted-docs.json");
 }
 function hostedDocsCacheKey(req, opts = {}) {
   const material = JSON.stringify([
@@ -5571,11 +3971,11 @@ function hostedDocsCacheKey(req, opts = {}) {
 }
 function loadFile(root) {
   try {
-    const parsed = JSON.parse(fs17.readFileSync(cachePath2(root), "utf8"));
-    if (parsed && parsed.version === CACHE_VERSION2 && parsed.entries && typeof parsed.entries === "object") return parsed;
+    const parsed = JSON.parse(fs18.readFileSync(cachePath(root), "utf8"));
+    if (parsed && parsed.version === CACHE_VERSION && parsed.entries && typeof parsed.entries === "object") return parsed;
   } catch {
   }
-  return { version: CACHE_VERSION2, entries: {} };
+  return { version: CACHE_VERSION, entries: {} };
 }
 function saveFile(root, file) {
   try {
@@ -5585,8 +3985,8 @@ function saveFile(root, file) {
         delete file.entries[k];
       }
     }
-    fs17.mkdirSync(cacheDir(root), { recursive: true });
-    fs17.writeFileSync(cachePath2(root), JSON.stringify(file));
+    fs18.mkdirSync(cacheDir(root), { recursive: true });
+    fs18.writeFileSync(cachePath(root), JSON.stringify(file));
   } catch {
   }
 }
@@ -5711,7 +4111,7 @@ function measure(root, files) {
   for (const rel2 of files) {
     let size;
     try {
-      size = fs17.statSync(path17.join(root, rel2)).size;
+      size = fs18.statSync(path2.join(root, rel2)).size;
     } catch {
       continue;
     }
@@ -5734,9 +4134,9 @@ function matchLines(text, needleLower) {
 }
 function readCandidate(abs, knownSize) {
   try {
-    const size = knownSize ?? fs17.statSync(abs).size;
+    const size = knownSize ?? fs18.statSync(abs).size;
     if (size > MAX_FILE_BYTES) return null;
-    const text = fs17.readFileSync(abs, "utf8");
+    const text = fs18.readFileSync(abs, "utf8");
     return text.includes(NUL) ? null : text;
   } catch {
     return null;
@@ -5747,7 +4147,7 @@ function scanInline(root, files, needleLower, cap, stopAtCap, sizes) {
   let total = 0;
   let truncated = false;
   for (const rel2 of files) {
-    const text = readCandidate(path17.join(root, rel2), sizes?.get(rel2));
+    const text = readCandidate(path2.join(root, rel2), sizes?.get(rel2));
     if (text === null) continue;
     for (const h of matchLines(text, needleLower)) {
       total++;
@@ -5814,12 +4214,12 @@ var WORKER_SOURCE = [
   "parentPort.postMessage({ hits, total, truncated });"
 ].join("\n");
 function runWorker(root, files, needleLower) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve11, reject) => {
     const w = new Worker(WORKER_SOURCE, { eval: true, workerData: { root, files, needleLower } });
     let settled = false;
     w.once("message", (m) => {
       settled = true;
-      resolve12(m);
+      resolve11(m);
     });
     w.once("error", reject);
     w.once("exit", (code) => {
@@ -5888,26 +4288,26 @@ var BINARY_EXTS = /* @__PURE__ */ new Set([
   ".pdf"
 ]);
 function hasBinaryExt(rel2) {
-  return BINARY_EXTS.has(path17.extname(rel2).toLowerCase());
+  return BINARY_EXTS.has(path2.extname(rel2).toLowerCase());
 }
 function toPosix2(rel2) {
-  return path17.sep === "\\" ? rel2.replaceAll("\\", "/") : rel2;
+  return path2.sep === "\\" ? rel2.replaceAll("\\", "/") : rel2;
 }
 async function searchSymbols(graph, root, query, limit) {
-  let q2 = query.trim();
-  if (!q2) return { matches: [], moreAvailable: false, hint: "query is required" };
-  const quoted = /^(["'`])(.+)\1$/.exec(q2);
-  if (quoted && quoted[2].trim()) q2 = quoted[2].trim();
-  const isPhrase = Boolean(quoted) || /\s/.test(q2) || /[/\\]/.test(q2) && !q2.includes(":") && !/[*?]/.test(q2);
-  let nodes = findNodes(graph, q2).filter((n) => n.kind !== "file");
+  let q = query.trim();
+  if (!q) return { matches: [], moreAvailable: false, hint: "query is required" };
+  const quoted = /^(["'`])(.+)\1$/.exec(q);
+  if (quoted && quoted[2].trim()) q = quoted[2].trim();
+  const isPhrase = Boolean(quoted) || /\s/.test(q) || /[/\\]/.test(q) && !q.includes(":") && !/[*?]/.test(q);
+  let nodes = findNodes(graph, q).filter((n) => n.kind !== "file");
   if (nodes.length === 0) {
-    nodes = fileSymbolNodes(graph, q2);
+    nodes = fileSymbolNodes(graph, q);
   }
   if (nodes.length === 0 && isPhrase) {
-    nodes = reconstructedIdentifierNodes(graph, q2);
+    nodes = reconstructedIdentifierNodes(graph, q);
   }
   if (nodes.length === 0) {
-    const tokens = queryTokens(q2);
+    const tokens = queryTokens(q);
     if (tokens.length >= 2) nodes = multiTokenNodes(graph, tokens);
   }
   const symbolCap = isPhrase ? Math.max(1, Math.floor(limit / 3)) : limit;
@@ -5922,10 +4322,10 @@ async function searchSymbols(graph, root, query, limit) {
   const textHits = [];
   let truncatedScan = false;
   let totalTextMatches;
-  const skipScan = !isPhrase && hasExactSymbolMatch(nodes, q2);
+  const skipScan = !isPhrase && hasExactSymbolMatch(nodes, q);
   if (spare > 0 && !skipScan) {
     const seen = new Set(symbolHits.map((h) => `${h.file}:${h.line}`));
-    const scan = await scanFiles(root, q2, spare, seen, textHits, isPhrase);
+    const scan = await scanFiles(root, q, spare, seen, textHits, isPhrase);
     truncatedScan = scan.truncated;
     if (isPhrase) totalTextMatches = scan.total;
   }
@@ -5946,25 +4346,25 @@ async function searchSymbols(graph, root, query, limit) {
   }
   return result;
 }
-function fileSymbolNodes(graph, q2) {
-  if (!/[/\\]/.test(q2) && !/\.\w+$/.test(q2)) return [];
-  const norm = q2.replaceAll("\\", "/").replace(/^\.\//, "");
+function fileSymbolNodes(graph, q) {
+  if (!/[/\\]/.test(q) && !/\.\w+$/.test(q)) return [];
+  const norm = q.replaceAll("\\", "/").replace(/^\.\//, "");
   const inFile = graph.nodes.filter(
     (n) => n.kind !== "file" && (n.file === norm || n.file.endsWith(`/${norm}`))
   );
   return [...inFile].sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName));
 }
-function hasExactSymbolMatch(nodes, q2) {
+function hasExactSymbolMatch(nodes, q) {
   if (nodes.length === 0) return false;
-  if (/^(.*):(\d+)$/.test(q2)) return true;
-  const lower = q2.toLowerCase();
-  return nodes.some((n) => n.id === q2 || n.qualifiedName.toLowerCase() === lower || n.name.toLowerCase() === lower);
+  if (/^(.*):(\d+)$/.test(q)) return true;
+  const lower = q.toLowerCase();
+  return nodes.some((n) => n.id === q || n.qualifiedName.toLowerCase() === lower || n.name.toLowerCase() === lower);
 }
-function queryTokens(q2) {
-  return [...new Set(q2.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2))];
+function queryTokens(q) {
+  return [...new Set(q.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2))];
 }
-function reconstructedIdentifierNodes(graph, q2) {
-  const words = q2.trim().split(/\s+/).filter(Boolean);
+function reconstructedIdentifierNodes(graph, q) {
+  const words = q.trim().split(/\s+/).filter(Boolean);
   if (words.length < 2) return [];
   const concat = findNodes(graph, words.join(""));
   if (concat.length) return concat.filter((n) => n.kind !== "file");
@@ -6030,13 +4430,13 @@ function walkCandidates(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
       if (e.name.startsWith(".") || IGNORE_DIRS.has(e.name)) continue;
-      const abs = path17.join(dir, e.name);
+      const abs = path2.join(dir, e.name);
       if (e.isDirectory()) {
         stack.push(abs);
         continue;
@@ -6046,7 +4446,7 @@ function walkCandidates(root) {
         truncated = true;
         continue;
       }
-      files.push(toPosix2(path17.relative(root, abs)));
+      files.push(toPosix2(path2.relative(root, abs)));
     }
   }
   files.sort();
@@ -6077,11 +4477,11 @@ function ripgrepCandidates(root, needle) {
   if (files.length > MAX_FILES_SCANNED) return { files: files.slice(0, MAX_FILES_SCANNED), truncated: true };
   return { files, truncated: false };
 }
-function parseRgFileList(stdout, sep10 = path17.sep) {
+function parseRgFileList(stdout, sep9 = path2.sep) {
   const seen = /* @__PURE__ */ new Set();
   for (const raw of stdout.split("\n")) {
     if (!raw) continue;
-    const posix3 = sep10 === "\\" ? raw.replaceAll("\\", "/") : raw;
+    const posix3 = sep9 === "\\" ? raw.replaceAll("\\", "/") : raw;
     const rel2 = posix3.startsWith("./") ? posix3.slice(2) : posix3;
     if (!rel2) continue;
     const segs = rel2.split("/");
@@ -6114,7 +4514,7 @@ function readyEmbedder(local) {
 async function retrieve(graph, question, budget, ctx) {
   let mode = "lexical";
   try {
-    const q2 = await withTimeout(
+    const q = await withTimeout(
       (async () => {
         const embedder = await readyEmbedder(ctx.local);
         if (!embedder) return null;
@@ -6126,7 +4526,7 @@ async function retrieve(graph, question, budget, ctx) {
       SEMANTIC_BUDGET_MS,
       "semantic path over budget"
     );
-    if (q2) return { q: q2, mode };
+    if (q) return { q, mode };
   } catch {
   }
   return { q: queryGraph(graph, question, { budget }), mode: "lexical" };
@@ -6175,10 +4575,10 @@ var TOOLS = [
       const question = String(args.question ?? args.query ?? "");
       if (!question) return { error: "bad_request", message: "question is required" };
       const budget = numOr(args.budget, 1500);
-      const { q: q2, mode } = await retrieve(graph, question, budget, ctx);
+      const { q, mode } = await retrieve(graph, question, budget, ctx);
       const rawScope = String(args.scope ?? "").trim();
       const scope = rawScope === "." || rawScope === "./" ? "" : rawScope.replace(/^\.\//, "");
-      const scoped = scope ? q2.matches.filter((m) => m.node.file.startsWith(scope)) : q2.matches;
+      const scoped = scope ? q.matches.filter((m) => m.node.file.startsWith(scope)) : q.matches;
       const detailed = isDetailed(args);
       let topImpact = null;
       const top = scoped[0]?.node;
@@ -6196,7 +4596,7 @@ var TOOLS = [
         mode,
         // The fact-annotated context block is detail: concise callers navigate
         // by the ranked matches and fetch nodes on demand (plan P2).
-        ...detailed ? { context: q2.context } : {},
+        ...detailed ? { context: q.context } : {},
         matches: shown.map((m) => ({ name: m.node.qualifiedName, kind: m.node.kind, file: m.node.file, line: m.node.span.start, score: m.score })),
         // A neutral availability flag, not a directive to keep querying: a
         // retrieval tool that coaches "narrow the question / see more" nudges the
@@ -6975,12 +5375,12 @@ function detectAssistants(root, opts = {}) {
   const which = opts.which ?? whichOnPath;
   const found = [];
   for (const assistant of ASSISTANTS) {
-    const repoHit = (assistant.markers ?? []).find((m) => fs17.existsSync(path17.join(root, m)));
+    const repoHit = (assistant.markers ?? []).find((m) => fs18.existsSync(path2.join(root, m)));
     if (repoHit) {
       found.push({ assistant, via: "repo", marker: repoHit });
       continue;
     }
-    const homeHit = (assistant.homeMarkers ?? []).find((m) => fs17.existsSync(path17.join(home, m)));
+    const homeHit = (assistant.homeMarkers ?? []).find((m) => fs18.existsSync(path2.join(home, m)));
     if (homeHit) {
       found.push({ assistant, via: "home", marker: homeHit });
       continue;
@@ -7012,19 +5412,19 @@ function installAssistant(a, opts) {
   const skipped = [];
   let note;
   if (a.skill) {
-    writeFileEnsured(path17.join(opts.root, a.skill), skillMarkdown(a.id));
+    writeFileEnsured(path2.join(opts.root, a.skill), skillMarkdown(a.id));
     wrote.push(a.skill);
   }
   if (a.mcp) {
     const launch = opts.launch ?? detectServeLaunch();
-    upsertMcp(path17.join(opts.root, a.mcp.file), a.mcp, launch);
+    upsertMcp(path2.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(path17.join(opts.root, a.nudge.file), a.nudge, opts.smallRepo, a.id);
+    writeNudge(path2.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)");
@@ -7034,41 +5434,41 @@ function installAssistant(a, opts) {
 function uninstallAssistant(a, root, purge) {
   const removed = [];
   if (a.mcp) {
-    const file = path17.join(root, a.mcp.file);
+    const file = path2.join(root, a.mcp.file);
     if (removeMcp(file, a.mcp)) removed.push(a.mcp.file);
   }
   if (a.nudge) {
-    const file = path17.join(root, a.nudge.file);
+    const file = path2.join(root, a.nudge.file);
     if (a.nudge.kind === "block") {
       if (removeBlock(file)) removed.push(a.nudge.file);
-    } else if (fs17.existsSync(file)) {
-      fs17.rmSync(file);
+    } else if (fs18.existsSync(file)) {
+      fs18.rmSync(file);
       removed.push(a.nudge.file);
     }
   }
   if (purge && a.skill) {
-    const file = path17.join(root, a.skill);
-    if (fs17.existsSync(file)) {
-      fs17.rmSync(file);
+    const file = path2.join(root, a.skill);
+    if (fs18.existsSync(file)) {
+      fs18.rmSync(file);
       removed.push(a.skill);
     }
   }
   return removed;
 }
 function writeFileEnsured(file, content) {
-  fs17.mkdirSync(path17.dirname(file), { recursive: true });
-  fs17.writeFileSync(file, content);
+  fs18.mkdirSync(path2.dirname(file), { recursive: true });
+  fs18.writeFileSync(file, content);
 }
 function writeNavigationConfig(root) {
   ensureVibgrateGitignore(root);
-  const rel2 = path17.join(".vibgrate", "mcp-navigation.json");
+  const rel2 = path2.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(path17.join(root, rel2), `${JSON.stringify(doc, null, 2)}
+  writeFileEnsured(path2.join(root, rel2), `${JSON.stringify(doc, null, 2)}
 `);
   return rel2;
 }
@@ -7083,7 +5483,7 @@ function upsertMcp(file, target, launch) {
 `);
 }
 function removeMcp(file, target) {
-  if (!fs17.existsSync(file)) return false;
+  if (!fs18.existsSync(file)) return false;
   const config = readJson(file);
   const bag = config[target.key];
   if (!bag || !(bag.vg !== void 0)) return false;
@@ -7102,8 +5502,8 @@ function refreshInstalledInstructions(root, smallRepo) {
   };
   for (const a of ASSISTANTS) {
     if (a.skill) {
-      const file = path17.join(root, a.skill);
-      if (fs17.existsSync(file)) {
+      const file = path2.join(root, a.skill);
+      if (fs18.existsSync(file)) {
         const text = readTextSafe(file);
         const from = text === null ? null : staleVersion(text, "# vg \u2014 the code map");
         if (from !== null) {
@@ -7113,8 +5513,8 @@ function refreshInstalledInstructions(root, smallRepo) {
       }
     }
     if (a.nudge) {
-      const file = path17.join(root, a.nudge.file);
-      if (!fs17.existsSync(file)) continue;
+      const file = path2.join(root, a.nudge.file);
+      if (!fs18.existsSync(file)) continue;
       const text = readTextSafe(file);
       if (text === null) continue;
       if (a.nudge.kind === "block") {
@@ -7138,7 +5538,7 @@ function refreshInstalledInstructions(root, smallRepo) {
 }
 function readTextSafe(file) {
   try {
-    return fs17.readFileSync(file, "utf8");
+    return fs18.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -7157,8 +5557,8 @@ ${stripMarkers(nudgeMarkdown(smallRepo, client))}` : stripMarkers(nudgeMarkdown(
   upsertBlock(file, nudgeMarkdown(smallRepo, client));
 }
 function upsertBlock(file, block) {
-  fs17.mkdirSync(path17.dirname(file), { recursive: true });
-  let existing = fs17.existsSync(file) ? fs17.readFileSync(file, "utf8") : "";
+  fs18.mkdirSync(path2.dirname(file), { recursive: true });
+  let existing = fs18.existsSync(file) ? fs18.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*$/, "")}
@@ -7166,20 +5566,20 @@ function upsertBlock(file, block) {
 ${block}
 ` : `${block}
 `;
-  fs17.writeFileSync(file, existing);
+  fs18.writeFileSync(file, existing);
 }
 function removeBlock(file) {
-  if (!fs17.existsSync(file)) return false;
-  const existing = fs17.readFileSync(file, "utf8");
+  if (!fs18.existsSync(file)) return false;
+  const existing = fs18.readFileSync(file, "utf8");
   const re = new RegExp(`\\n*${escapeRe(NUDGE_BEGIN)}[\\s\\S]*?${escapeRe(NUDGE_END)}\\n*`);
   if (!re.test(existing)) return false;
-  fs17.writeFileSync(file, existing.replace(re, "\n"));
+  fs18.writeFileSync(file, existing.replace(re, "\n"));
   return true;
 }
 function readJson(file) {
-  if (!fs17.existsSync(file)) return {};
+  if (!fs18.existsSync(file)) return {};
   try {
-    const parsed = JSON.parse(fs17.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -7199,7 +5599,7 @@ function escapeRe(s) {
 }
 var REFRESH_LOCK_STALE_MS = 10 * 60 * 1e3;
 function refreshLockPath(root) {
-  return path17.join(cacheDir(root), "refresh.lock");
+  return path2.join(cacheDir(root), "refresh.lock");
 }
 async function refreshIfStale(root, opts = {}) {
   const probe = probeFreshness(root);
@@ -7230,8 +5630,8 @@ async function refreshIfStale(root, opts = {}) {
       const dir = vibgrateDir(root);
       writeArtifacts(result.graph, {
         root,
-        report: fs17.existsSync(path17.join(dir, "GRAPH_REPORT.md")),
-        html: fs17.existsSync(path17.join(dir, "graph.html"))
+        report: fs18.existsSync(path2.join(dir, "GRAPH_REPORT.md")),
+        html: fs18.existsSync(path2.join(dir, "graph.html"))
       });
     }
     writeSnapshot(root, result.graph.provenance.corpusHash, result.fileStats, scope);
@@ -7250,583 +5650,7 @@ 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", "search_symbols"]);
-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 savingsLedgerPath(root) {
-  return path17.join(cacheDir(root), LEDGER);
-}
-function ledgerPath(root) {
-  return savingsLedgerPath(root);
-}
-function savingsRecorded(root) {
-  return fs17.existsSync(ledgerPath(root));
-}
-function clearSavings(root) {
-  const file = ledgerPath(root);
-  const existed = fs17.existsSync(file);
-  fs17.rmSync(file, { force: true });
-  fs17.rmSync(path17.join(cacheDir(root), "stats-share.json"), { force: true });
-  return existed;
-}
-function recordSaving(root, entry, now) {
-  try {
-    fs17.mkdirSync(cacheDir(root), { recursive: true });
-    const line = JSON.stringify({ ts: now, ...entry });
-    fs17.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 (fs17.existsSync(file)) {
-    for (const line of fs17.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 msByTool = /* @__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 (fs17.existsSync(file)) {
-    for (const line of fs17.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);
-        if (typeof e.ms === "number" && e.ms >= 0) {
-          const timing = msByTool.get(e.tool) ?? { sum: 0, n: 0 };
-          timing.sum += e.ms;
-          timing.n++;
-          msByTool.set(e.tool, timing);
-        }
-      } catch {
-      }
-    }
-  }
-  const commands = toDimensionStats(byTool).map((d) => {
-    const timing = msByTool.get(d.key);
-    return {
-      tool: d.key,
-      calls: d.calls,
-      complete: d.complete,
-      partial: d.partial,
-      miss: d.miss,
-      successPct: d.successPct,
-      avgMs: timing && timing.n > 0 ? Math.round(timing.sum / timing.n) : null
-    };
-  });
-  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
-  };
-}
-var PROBE_INTERVAL_MS = 2e3;
-var MAX_PROBE_INTERVAL_MS = 3e4;
-var PROBE_DUTY_FACTOR = 20;
-var REFRESH_BUDGET_MS = 5e3;
-var FAILURE_COOLDOWN_MS = 6e4;
-var GraphSource = class {
-  constructor(graphPath, refresh = false, tuning = {}) {
-    this.graphPath = graphPath;
-    this.refresh = refresh;
-    this.tuning = tuning;
-    this.root = path17.dirname(path17.dirname(graphPath));
-  }
-  graphPath;
-  refresh;
-  tuning;
-  cachedMtimeMs = -1;
-  cached = null;
-  root;
-  lastProbeAt = 0;
-  failedUntil = 0;
-  inflight = null;
-  /** Self-tuned: grows with measured probe cost so huge repos aren't penalized. */
-  probeIntervalMs = PROBE_INTERVAL_MS;
-  /** Current graph: auto-refreshed if the tree drifted, reloaded if the file changed. */
-  async get() {
-    if (this.refresh) await this.maybeRefresh();
-    const stat = fs17.statSync(this.graphPath);
-    if (stat.mtimeMs !== this.cachedMtimeMs || !this.cached) {
-      this.cached = parseGraph(fs17.readFileSync(this.graphPath, "utf8"));
-      this.cachedMtimeMs = stat.mtimeMs;
-    }
-    return this.cached;
-  }
-  /**
-   * Debounced, single-flight refresh. Never throws — a refresh problem must
-   * degrade to "answer from the current map", not break the tool call.
-   */
-  async maybeRefresh() {
-    const now = Date.now();
-    if (!this.inflight) {
-      const interval = this.tuning.probeIntervalMs ?? this.probeIntervalMs;
-      if (now < this.failedUntil || now - this.lastProbeAt < interval) return;
-      this.lastProbeAt = now;
-      this.inflight = refreshIfStale(this.root).then((r) => {
-        if (r.status === "error") this.failedUntil = Date.now() + FAILURE_COOLDOWN_MS;
-        if (r.status === "fresh" || r.status === "no-snapshot" || r.status === "locked") {
-          const cost = Date.now() - now;
-          this.probeIntervalMs = Math.min(
-            MAX_PROBE_INTERVAL_MS,
-            Math.max(PROBE_INTERVAL_MS, cost * PROBE_DUTY_FACTOR)
-          );
-        }
-      }).catch(() => {
-        this.failedUntil = Date.now() + FAILURE_COOLDOWN_MS;
-      }).finally(() => {
-        this.inflight = null;
-      });
-    }
-    await Promise.race([this.inflight, sleep(this.tuning.refreshBudgetMs ?? REFRESH_BUDGET_MS)]);
-  }
-};
-function createServer(source, opts = {}) {
-  const { savings = false, shareStats = false, local = false, dedup = false, stats } = opts;
-  const record = savings || shareStats;
-  const root = path17.dirname(path17.dirname(source.graphPath));
-  const seen = /* @__PURE__ */ new Set();
-  const server = new Server(
-    { name: "vg", version: VERSION },
-    {
-      capabilities: { tools: {} },
-      // Routing guidance once at the server level (hosts that surface
-      // `instructions` get it at zero per-step schema cost): the flashlight
-      // vs the map.
-      instructions: 'vg is a code map. Use search_symbols to find a known name or literal string fast \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. For how-do-I-use-this-library questions call resolve_library once, then library_docs with the returned targetId and a focused query: the docs are official and matched to the version THIS project has installed (drift-annotated) \u2014 prefer them over web search or training-data recall when they conflict. Skip them for language built-ins or APIs already shown in context. If two library_docs calls have not surfaced the section you need, read the package source under node_modules instead of searching again.'
-    }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOLS.map((t) => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema,
-      annotations: { readOnlyHint: true, openWorldHint: false }
-    }))
-  }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const tool = TOOLS.find((t) => t.name === request.params.name);
-    if (!tool) {
-      return errorResult(`unknown tool "${request.params.name}"`);
-    }
-    let graph;
-    try {
-      graph = await source.get();
-    } catch {
-      return errorResult(
-        "no code map found. Run `vg` in the project to build .vibgrate/graph.json, then retry."
-      );
-    }
-    const startedAt = Date.now();
-    try {
-      const args = request.params.arguments ?? {};
-      const result = await tool.handler(graph, args, { root, local, dedup, seen });
-      const ms = Date.now() - startedAt;
-      stats?.record({ ...measureCall(tool.name, result), client: sanitizeClient(detectClient(server)), ms });
-      if (record) recordUsage(root, tool.name, result, detectClient(server), ms);
-      return renderToolResult(result);
-    } catch (err) {
-      stats?.record({
-        tool: tool.name,
-        client: sanitizeClient(detectClient(server)),
-        outcome: "miss",
-        ms: Date.now() - startedAt,
-        vgTokens: 0,
-        baselineTokens: 0
-      });
-      return errorResult(`tool "${tool.name}" failed: ${err.message}`);
-    }
-  });
-  return server;
-}
-async function serveStdio(graphPath, opts = {}) {
-  const source = new GraphSource(graphPath, opts.refresh !== false);
-  const server = createServer(source, opts);
-  warmEmbedderInBackground(opts.local);
-  await server.connect(new StdioServerTransport());
-}
-function sleep(ms) {
-  return new Promise((resolve12) => {
-    const timer = setTimeout(resolve12, ms);
-    timer.unref?.();
-  });
-}
-function recordUsage(root, tool, result, client, ms) {
-  recordSaving(
-    root,
-    { ...measureCall(tool, result), source: "mcp", client: sanitizeClient(client), ...ms !== void 0 ? { ms } : {} },
-    Date.now()
-  );
-}
-function measureCall(tool, result) {
-  const outcome = classifyOutcome(result);
-  let vgTokens = 0;
-  let baselineTokens = 0;
-  if (SAVINGS_TOOLS.has(tool) && result && typeof result === "object") {
-    vgTokens = countTokens(renderedText(renderToolResult(result)));
-    baselineTokens = referencedFiles(result).size * PER_FILE_TOKENS;
-  }
-  return { tool, outcome, vgTokens, baselineTokens };
-}
-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";
-  if (!result || typeof result !== "object") return "miss";
-  const r = result;
-  if (typeof r.error === "string" && r.error) return "miss";
-  if (r.connected === false) return "miss";
-  if (Array.isArray(r.matches) && r.matches.length === 0) return "miss";
-  return isPartial(r) ? "partial" : "complete";
-}
-function isPartial(r) {
-  if (r.moreAvailable === true) return true;
-  if (r._truncated && typeof r._truncated === "object") return true;
-  for (const [key, value] of Object.entries(r)) {
-    if (typeof value !== "number" || !key.endsWith("Total")) continue;
-    const base = key.slice(0, -"Total".length);
-    const shown = Array.isArray(r[base]) ? r[base].length : 0;
-    if (value > shown) return true;
-  }
-  return false;
-}
-function renderedText(rendered) {
-  const block = rendered.content?.find((b) => b.type === "text");
-  return block && "text" in block && typeof block.text === "string" ? block.text : "";
-}
-function referencedFiles(result) {
-  const r = result;
-  const files = /* @__PURE__ */ new Set();
-  if (typeof r.file === "string" && r.file) files.add(r.file);
-  for (const m of asArray(r.matches)) {
-    const f = m.file;
-    if (typeof f === "string" && f) files.add(f);
-  }
-  for (const name of [...asArray(r.calls), ...asArray(r.calledBy)]) {
-    if (typeof name !== "string") continue;
-    const i = name.indexOf(":");
-    if (i > 0) files.add(name.slice(0, i));
-  }
-  return files;
-}
-function asArray(v) {
-  return Array.isArray(v) ? v : [];
-}
-function errorResult(message) {
-  return { content: [{ type: "text", text: message }], isError: true };
-}
-
-// src/engine/export.ts
-function formatForExt(ext) {
-  switch (ext.toLowerCase()) {
-    case ".json":
-      return "json";
-    case ".ndjson":
-      return "ndjson";
-    case ".graphml":
-      return "graphml";
-    case ".dot":
-    case ".gv":
-      return "dot";
-    case ".cypher":
-      return "cypher";
-    case ".sql":
-      return "sql";
-    case ".md":
-      return "md";
-    case ".html":
-      return "html";
-    default:
-      return null;
-  }
-}
-function exportGraph(format, ctx) {
-  switch (format) {
-    case "json":
-      return serializeGraph(ctx.graph);
-    case "md":
-      return renderReport(ctx.graph);
-    case "html":
-      return renderHtml(ctx.graph);
-    case "ndjson":
-      return ndjson(ctx.graph);
-    case "graphml":
-      return graphml(ctx.graph);
-    case "dot":
-      return dot(ctx.graph);
-    case "cypher":
-      return cypher(ctx.graph);
-    case "sql":
-      return sql(ctx);
-    case "cyclonedx":
-      return cyclonedx(ctx);
-    case "spdx":
-      return spdx(ctx);
-  }
-}
-function ndjson(graph) {
-  const rows = graph.facts && graph.facts.length ? graph.facts : graph.nodes;
-  return rows.map((r) => JSON.stringify(r)).join("\n") + "\n";
-}
-function esc2(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function graphml(graph) {
-  const lines = [];
-  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
-  lines.push('<graphml xmlns="http://graphml.graphdrawing.org/xmlns">');
-  lines.push('  <key id="name" for="node" attr.name="name" attr.type="string"/>');
-  lines.push('  <key id="kind" for="node" attr.name="kind" attr.type="string"/>');
-  lines.push('  <key id="file" for="node" attr.name="file" attr.type="string"/>');
-  lines.push('  <key id="ekind" for="edge" attr.name="kind" attr.type="string"/>');
-  lines.push('  <graph edgedefault="directed">');
-  for (const n of graph.nodes) {
-    lines.push(`    <node id="${esc2(n.id)}"><data key="name">${esc2(n.qualifiedName)}</data><data key="kind">${esc2(n.kind)}</data><data key="file">${esc2(n.file)}</data></node>`);
-  }
-  for (const e of graph.edges) {
-    lines.push(`    <edge source="${esc2(e.src)}" target="${esc2(e.dst)}"><data key="ekind">${esc2(e.kind)}</data></edge>`);
-  }
-  lines.push("  </graph>");
-  lines.push("</graphml>");
-  return lines.join("\n") + "\n";
-}
-function dot(graph) {
-  const lines = ["digraph vg {"];
-  for (const n of graph.nodes) lines.push(`  "${n.id}" [label="${dotEsc(n.qualifiedName)}"];`);
-  for (const e of graph.edges) lines.push(`  "${e.src}" -> "${e.dst}" [label="${e.kind}"];`);
-  lines.push("}");
-  return lines.join("\n") + "\n";
-}
-function dotEsc(s) {
-  return s.replace(/"/g, '\\"');
-}
-function cypher(graph) {
-  const lines = [];
-  for (const n of graph.nodes) {
-    lines.push(
-      `CREATE (:\`${cypherLabel(n.kind)}\` {id:${q(n.id)}, name:${q(n.qualifiedName)}, file:${q(n.file)}});`
-    );
-  }
-  for (const e of graph.edges) {
-    lines.push(
-      `MATCH (a {id:${q(e.src)}}),(b {id:${q(e.dst)}}) CREATE (a)-[:\`${cypherLabel(e.kind)}\`]->(b);`
-    );
-  }
-  return lines.join("\n") + "\n";
-}
-function cypherLabel(s) {
-  return s.replace(/[^A-Za-z0-9_]/g, "_");
-}
-function q(s) {
-  return JSON.stringify(s);
-}
-function sql(ctx) {
-  const graph = ctx.graph;
-  const lines = [];
-  lines.push("BEGIN;");
-  lines.push("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);");
-  const meta = [
-    ["schemaVersion", graph.schemaVersion],
-    ["generatedAt", ctx.generatedAt],
-    ["corpusHash", graph.provenance.corpusHash],
-    ["tool", graph.provenance.tool],
-    ["toolVersion", graph.provenance.version],
-    ["resolver", graph.provenance.resolver.join(",")],
-    ["fingerprint", graph.provenance.toolchain?.fingerprint ?? null]
-  ];
-  for (const [k, v] of meta) lines.push(`INSERT INTO meta VALUES (${sqlStr(k)}, ${sqlStr(v)});`);
-  lines.push(
-    "CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, kind TEXT, name TEXT, qualified_name TEXT, file TEXT, span_start INTEGER, span_end INTEGER, lang TEXT, visibility TEXT, signature TEXT, importance REAL, area INTEGER, is_hub INTEGER, tested INTEGER, coverage REAL);"
-  );
-  for (const n of graph.nodes) {
-    lines.push(
-      `INSERT INTO nodes VALUES (${sqlStr(n.id)}, ${sqlStr(n.kind)}, ${sqlStr(n.name)}, ${sqlStr(n.qualifiedName)}, ${sqlStr(n.file)}, ${sqlNum(n.span.start)}, ${sqlNum(n.span.end)}, ${sqlStr(n.lang)}, ${sqlStr(n.visibility)}, ${sqlStr(n.signature)}, ${sqlNum(n.importance)}, ${sqlNum(n.area)}, ${sqlBool(n.isHub)}, ${sqlBool(n.tested)}, ${sqlNum(n.coverage)});`
-    );
-  }
-  lines.push(
-    'CREATE TABLE IF NOT EXISTS edges (id TEXT PRIMARY KEY, kind TEXT, src TEXT, dst TEXT, resolution TEXT, confidence REAL, epistemic TEXT, surprise REAL, "count" INTEGER);'
-  );
-  for (const e of graph.edges) {
-    lines.push(
-      `INSERT INTO edges VALUES (${sqlStr(e.id)}, ${sqlStr(e.kind)}, ${sqlStr(e.src)}, ${sqlStr(e.dst)}, ${sqlStr(e.resolution)}, ${sqlNum(e.confidence)}, ${sqlStr(e.epistemic)}, ${sqlNum(e.surprise)}, ${sqlNum(e.count)});`
-    );
-  }
-  lines.push("CREATE TABLE IF NOT EXISTS areas (id INTEGER PRIMARY KEY, label TEXT, size INTEGER, cohesion REAL, external_edges INTEGER);");
-  lines.push("CREATE TABLE IF NOT EXISTS area_members (area_id INTEGER, node_id TEXT);");
-  for (const a of graph.areas) {
-    lines.push(`INSERT INTO areas VALUES (${sqlNum(a.id)}, ${sqlStr(a.label)}, ${sqlNum(a.size)}, ${sqlNum(a.cohesion)}, ${sqlNum(a.externalEdges)});`);
-    for (const m of a.members) lines.push(`INSERT INTO area_members VALUES (${sqlNum(a.id)}, ${sqlStr(m)});`);
-  }
-  if (graph.facts && graph.facts.length) {
-    lines.push("CREATE TABLE IF NOT EXISTS facts (id TEXT PRIMARY KEY, kind TEXT, predicate_json TEXT, derived_by TEXT, confidence TEXT);");
-    lines.push("CREATE TABLE IF NOT EXISTS fact_subjects (fact_id TEXT, node_id TEXT);");
-    lines.push("CREATE TABLE IF NOT EXISTS fact_evidence (fact_id TEXT, file TEXT, span_start INTEGER, span_end INTEGER);");
-    for (const f of graph.facts) {
-      lines.push(`INSERT INTO facts VALUES (${sqlStr(f.id)}, ${sqlStr(f.kind)}, ${sqlStr(JSON.stringify(f.predicate))}, ${sqlStr(f.derivedBy)}, ${sqlStr(f.confidence)});`);
-      for (const s of f.subjectIds) lines.push(`INSERT INTO fact_subjects VALUES (${sqlStr(f.id)}, ${sqlStr(s)});`);
-      for (const ev of f.evidence) lines.push(`INSERT INTO fact_evidence VALUES (${sqlStr(f.id)}, ${sqlStr(ev.file)}, ${sqlNum(ev.span.start)}, ${sqlNum(ev.span.end)});`);
-    }
-  }
-  lines.push("COMMIT;");
-  return lines.join("\n") + "\n";
-}
-function sqlStr(v) {
-  if (v == null) return "NULL";
-  return `'${v.replace(/'/g, "''")}'`;
-}
-function sqlNum(v) {
-  return v == null || !Number.isFinite(v) ? "NULL" : String(v);
-}
-function sqlBool(v) {
-  return v == null ? "NULL" : v ? "1" : "0";
-}
-function cyclonedx(ctx) {
-  const components = [];
-  for (const d of ctx.deps ?? []) {
-    components.push({
-      type: "library",
-      name: d.name,
-      version: d.installed ?? d.declared,
-      purl: d.ecosystem === "npm" ? `pkg:npm/${d.name}@${d.installed ?? ""}` : void 0
-    });
-  }
-  for (const m of ctx.models ?? []) {
-    components.push({ type: "machine-learning-model", name: m.name, properties: [{ name: "vg:runtime", value: m.runtime }] });
-  }
-  const bom = {
-    bomFormat: "CycloneDX",
-    specVersion: "1.6",
-    metadata: { timestamp: ctx.generatedAt, tools: [{ name: "vg", version: ctx.graph.provenance.version }] },
-    components
-  };
-  return JSON.stringify(bom, null, 2) + "\n";
-}
-function spdx(ctx) {
-  const packages = (ctx.deps ?? []).map((d) => ({
-    SPDXID: `SPDXRef-Package-${cypherLabel(d.name)}`,
-    name: d.name,
-    versionInfo: d.installed ?? d.declared,
-    downloadLocation: "NOASSERTION"
-  }));
-  const doc = {
-    spdxVersion: "SPDX-2.3",
-    dataLicense: "CC0-1.0",
-    SPDXID: "SPDXRef-DOCUMENT",
-    name: "vg-sbom",
-    creationInfo: { created: ctx.generatedAt, creators: [`Tool: vg-${ctx.graph.provenance.version}`] },
-    packages
-  };
-  return JSON.stringify(doc, null, 2) + "\n";
-}
 
-export { ASSISTANTS, CLI_TOOL_ALIASES, CliError, ECOSYSTEMS, ExitCode, FREE_PACK, GraphIndex, GraphSource, NPX_INVOCATION, ResourceLimitError, SAVINGS_TOOLS, SCHEMA_VERSION, SKIP_DIRS, SKIP_FILES, SMALL_REPO_FILES, TOOLS, UsageError, addLibrary, analyze, applyCoverage, applyStaticTestLinkage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, buildModuleResolver, cacheDir, catalogPath, clearModelCache, clearSavings, clearStoredCredentials, cosine, countPending, countTokens, coveringTests, createServer, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, defaultGraphPath, detectAssistants, detectRunner, detectServeLaunch, discover, discoverModels, driftCount, driftFor, dsnCommand, embeddingsCached, enrichOnline, ensureGitignored, epistemicBreakdown, exportGraph, fetchHostedDocsCached, findGitRoot, findNodes, formatForExt, getNodeEmbeddings, gitignoreEntryForCredentials, groundGraph, hasDrift, homeCredentialsPath, hostedBase, identifierParts, impactOf, indexFor, ingestHostForRegionId, installAssistant, inventory, isModelReady, isTestFile, libDir, libId, loadCatalog, loadCoverage, loadEmbedder, loadGraph, loadSnapshot, localApiSurface, localPackageDocs, modelCacheInfo, nodeById, nodeEmbedText, parseDsn, parseGraph, parseJsonc, probeFreshness, projectCredentialsPath, publishPrivateLibrary, pushCommand, queryGraph, queryGraphSemantic, readDoc, readSavings, readScanArtifact, readStoredCredentials, readUsage, recordCliCall, recordSaving, refreshIfStale, refreshInstalledInstructions, relativeResolver, renderHtml, renderReport, resolveCliInvocation, resolveDsn, resolveEmbedModel, resolveIngestHost, resolveLib, resolveLimits, resolveOne, resolveVersion, sanitizeClient, saveCatalog, savingsLedgerPath, savingsRecorded, scipEdges, selectForBudget, serializeGraph, serveStdio, shortestPath, stableStringify, symbolsFromApi, testsToRun, unavailableMessage, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, vibgrateDir, writeArtifacts, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
-//# sourceMappingURL=chunk-3DPZQS2Q.js.map
-//# sourceMappingURL=chunk-3DPZQS2Q.js.map
+export { ASSISTANTS, CliError, ExitCode, FREE_PACK, NPX_INVOCATION, ResourceLimitError, SCHEMA_VERSION, SKIP_DIRS, SKIP_FILES, SMALL_REPO_FILES, TOOLS, UsageError, analyze, applyCoverage, applyStaticTestLinkage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, buildModuleResolver, clearStoredCredentials, countTokens, coveringTests, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, defaultGraphPath, detectAssistants, detectRunner, detectServeLaunch, discover, discoverModels, driftCount, dsnCommand, ensureGitignored, epistemicBreakdown, fetchHostedDocsCached, findGitRoot, gitignoreEntryForCredentials, groundGraph, hasDrift, homeCredentialsPath, hostedBase, ingestHostForRegionId, installAssistant, isTestFile, loadCoverage, loadGraph, loadSnapshot, parseDsn, parseJsonc, probeFreshness, projectCredentialsPath, publishPrivateLibrary, pushCommand, readScanArtifact, readStoredCredentials, refreshIfStale, refreshInstalledInstructions, relativeResolver, renderHtml, renderReport, renderToolResult, resolveCliInvocation, resolveDsn, resolveIngestHost, resolveLimits, scipEdges, selectForBudget, shortestPath, symbolsFromApi, testsToRun, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, vibgrateDir, warmEmbedderInBackground, writeArtifacts, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
+//# sourceMappingURL=chunk-VXT6LUGP.js.map
+//# sourceMappingURL=chunk-VXT6LUGP.js.map