@vibgrate/cli 2026.727.2 → 2026.727.4

package/dist/{chunk-KNELIQJO.js → chunk-YKVH2PGF.js}

@@ -1,17 +1,17 @@
-import { loadConfig, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-WGUL45AV.js';
-import { resolveVersion, resolveLib, loadCatalog, driftFor, localPackageDocs, readDoc, inventory, localApiSurface, edgeId, buildModuleResolver, resolve, applyStaticTestLinkage, nodeId } from './chunk-LKVMI67M.js';
+import { resolveVersion, resolveLib, loadCatalog, driftFor, localPackageDocs, readDoc, inventory, localApiSurface, edgeId, buildModuleResolver, resolve, applyStaticTestLinkage, nodeId } from './chunk-6AXHLQBV.js';
+import { loadConfig, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-T3AYRS7J.js';
+import { writeTextFile, pathExists, readJsonFile } from './chunk-CRAMOEBE.js';
 import { resolveOne, findNodes } from './chunk-J7LKEB2R.js';
-import { discoverModels } from './chunk-OOIG3RUM.js';
-import { impactOf, indexFor, withTimeout, getNodeEmbeddings, queryGraphSemantic, queryGraph, loadEmbedder, isModelReady, acquireLock, releaseLock } from './chunk-6ABXHZRN.js';
-import { langById, grammarSetVersion, langForExtension, setGrammarsOverride, parseSource } from './chunk-3Q7QBWFW.js';
+import { impactOf, indexFor, withTimeout, getNodeEmbeddings, queryGraphSemantic, queryGraph, loadEmbedder, isModelReady, acquireLock, releaseLock } from './chunk-6UK6QPTR.js';
+import { discoverModels } from './chunk-3SDV6ADQ.js';
+import { langById, grammarSetVersion, langForExtension, setGrammarsOverride, parseSource } from './chunk-ON25BX6T.js';
 import { redactSecrets } from './chunk-RXP66R2E.js';
-import { writeGraphIndex, SCHEMA_VERSION, loadGraph, ensureVibgrateGitignore, vibgrateDir, writeArtifacts } from './chunk-2XQDMLKB.js';
-import { cacheDir, loadCache, serializeGraph, stableStringify } from './chunk-K3MZIVZW.js';
+import { writeGraphIndex, SCHEMA_VERSION, loadGraph, ensureVibgrateGitignore, vibgrateDir, writeArtifacts } from './chunk-B3YUO3NW.js';
+import { cacheDir, loadCache, serializeGraph, stableStringify } from './chunk-ZKNB4YH4.js';
 import { shortId, canonicalize, hashString, hashBytes } from './chunk-JFGYT6BI.js';
-import { writeTextFile, pathExists, readJsonFile } from './chunk-CRAMOEBE.js';
-import * as fs16 from 'fs';
+import * as fs18 from 'fs';
 import { spawnSync, execFileSync } from 'child_process';
-import * as path18 from 'path';
+import * as path19 from 'path';
 import ignore from 'ignore';
 import * as v8 from 'v8';
 import Graph from 'graphology';
@@ -22,6 +22,7 @@ import louvain from 'graphology-communities-louvain';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
 import ts from 'typescript';
+import * as fs8 from 'fs/promises';
 import { bidirectional } from 'graphology-shortest-path/unweighted.js';
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
@@ -46,9 +47,9 @@ function whichOnPath(cmd) {
 }
 function isOwnBinary(binPath) {
   try {
-    const real = fs16.realpathSync(binPath);
+    const real = fs18.realpathSync(binPath);
     if (/[\\/]@vibgrate[\\/]cli[\\/]/.test(real)) return true;
-    const head = fs16.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;
@@ -58,7 +59,7 @@ function isEphemeralNpxBinary(binPath) {
   const NPX_SEGMENT = /[\\/]_npx[\\/]/;
   if (NPX_SEGMENT.test(binPath)) return true;
   try {
-    return NPX_SEGMENT.test(fs16.realpathSync(binPath));
+    return NPX_SEGMENT.test(fs18.realpathSync(binPath));
   } catch {
     return false;
   }
@@ -235,19 +236,19 @@ var SKIP_FILES = /* @__PURE__ */ new Set([
   "flake.lock"
 ]);
 function toPosix(p) {
-  return p.split(path18.sep).join("/");
+  return p.split(path19.sep).join("/");
 }
 function buildRootIgnore(root, exclude) {
   const ig = ignore();
-  const gitignorePath = path18.join(root, ".gitignore");
-  if (fs16.existsSync(gitignorePath)) {
-    ig.add(fs16.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path19.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 = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   const onlyLangs = (options.only ?? []).filter(Boolean);
   const allowLang = (lang) => onlyLangs.length === 0 || onlyLangs.includes(lang.id);
   for (const id of onlyLangs) {
@@ -256,27 +257,27 @@ function discover(options) {
     }
   }
   const rootIg = buildRootIgnore(root, options.exclude ?? []);
-  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path18.resolve(root, p)) : [root]).filter((p) => fs16.existsSync(p));
+  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path19.resolve(root, p)) : [root]).filter((p) => fs18.existsSync(p));
   const found = /* @__PURE__ */ new Map();
   const considerFile = (abs) => {
-    const rel2 = toPosix(path18.relative(root, abs));
+    const rel2 = toPosix(path19.relative(root, abs));
     if (rel2.startsWith("..")) return;
     if (rel2 === "" || rootIg.ignores(rel2)) return;
-    if (SKIP_FILES.has(path18.basename(abs).toLowerCase())) return;
-    const lang = langForExtension(path18.extname(abs));
+    if (SKIP_FILES.has(path19.basename(abs).toLowerCase())) return;
+    const lang = langForExtension(path19.extname(abs));
     if (!lang || !allowLang(lang)) return;
     found.set(rel2, { rel: rel2, abs, lang });
   };
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs16.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const abs = path18.join(dir, entry.name);
-      const rel2 = toPosix(path18.relative(root, abs));
+      const abs = path19.join(dir, entry.name);
+      const rel2 = toPosix(path19.relative(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         if (rel2 && rootIg.ignores(`${rel2}/`)) continue;
@@ -287,7 +288,7 @@ function discover(options) {
     }
   };
   for (const scope of scopeAbs) {
-    const stat = fs16.statSync(scope);
+    const stat = fs18.statSync(scope);
     if (stat.isDirectory()) walk(scope);
     else if (stat.isFile()) considerFile(scope);
   }
@@ -769,14 +770,14 @@ var DEFAULT_PATHS = [
 ];
 function loadCoverage(root, explicit) {
   const candidates = (explicit && explicit.length ? explicit : DEFAULT_PATHS).map(
-    (p) => path18.resolve(root, p)
+    (p) => path19.resolve(root, p)
   );
-  const found = candidates.filter((p) => fs16.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 = fs16.readFileSync(file, "utf8");
+      const text = fs18.readFileSync(file, "utf8");
       if (file.endsWith(".json")) mergeIstanbul(map, text, root);
       else mergeLcov(map, text, root);
     } catch {
@@ -785,8 +786,8 @@ function loadCoverage(root, explicit) {
   return map.size ? map : null;
 }
 function rel(root, p) {
-  const abs = path18.isAbsolute(p) ? p : path18.resolve(root, p);
-  return path18.relative(root, abs).split(path18.sep).join("/");
+  const abs = path19.isAbsolute(p) ? p : path19.resolve(root, p);
+  return path19.relative(root, abs).split(path19.sep).join("/");
 }
 function bump(map, file, line, hits) {
   let lh = map.get(file);
@@ -1093,7 +1094,7 @@ async function parseInline(files, options) {
   onProgress?.(0, files.length);
   for (const file of files) {
     try {
-      const source = fs16.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}`));
@@ -1148,9 +1149,9 @@ function isWorkerOom(err) {
   return e?.code === "ERR_WORKER_OUT_OF_MEMORY" || /out of memory/i.test(e?.message ?? "");
 }
 function resolveWorkerFile() {
-  const here = path18.dirname(fileURLToPath(import.meta.url));
-  const candidate = path18.join(here, "parse-worker.js");
-  return fs16.existsSync(candidate) ? candidate : null;
+  const here = path19.dirname(fileURLToPath(import.meta.url));
+  const candidate = path19.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) }, () => []);
@@ -1399,7 +1400,7 @@ function enclosing3(nodes, line) {
   return best;
 }
 function normalize2(p) {
-  return path18.resolve(p).split(path18.sep).join("/");
+  return path19.resolve(p).split(path19.sep).join("/");
 }
 
 // src/engine/epistemic.ts
@@ -1642,14 +1643,14 @@ var IMPORTANCE = {
   "other-config": 0.08
 };
 function toPosix2(p) {
-  return p.split(path18.sep).join("/");
+  return p.split(path19.sep).join("/");
 }
 function buildRootIgnore2(root, exclude) {
   const ig = ignore();
-  const gitignorePath = path18.join(root, ".gitignore");
-  if (fs16.existsSync(gitignorePath)) {
+  const gitignorePath = path19.join(root, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) {
     try {
-      ig.add(fs16.readFileSync(gitignorePath, "utf8"));
+      ig.add(fs18.readFileSync(gitignorePath, "utf8"));
     } catch {
     }
   }
@@ -1658,7 +1659,7 @@ function buildRootIgnore2(root, exclude) {
 }
 function classifyProjectContext(relOrName) {
   const rel2 = relOrName.replace(/\\/g, "/");
-  const base = path18.basename(rel2);
+  const base = path19.basename(rel2);
   const baseLower = base.toLowerCase();
   if (/^\.env($|\.)/i.test(base) && !isEnvExampleName(baseLower)) return null;
   if (SKIP_FILES.has(baseLower)) return null;
@@ -1671,7 +1672,7 @@ function classifyProjectContext(relOrName) {
   for (const { re, category } of PATH_PATTERNS) {
     if (re.test(rel2)) return category;
   }
-  const ext = path18.extname(baseLower);
+  const ext = path19.extname(baseLower);
   if (DOC_EXTENSIONS.has(ext)) return ext === ".txt" ? "text" : "markdown";
   if (API_EXTENSIONS.has(ext)) return "api-contract";
   if ((ext === ".yaml" || ext === ".yml" || ext === ".json") && /openapi|swagger|asyncapi/i.test(base)) {
@@ -1689,24 +1690,24 @@ function isEnvExampleName(baseLower) {
   return false;
 }
 function discoverDocs(options) {
-  const root = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   const maxFiles = options.maxFiles ?? DOC_MAX_FILES;
   const rootIg = buildRootIgnore2(root, options.exclude ?? []);
-  const scopeAbs = (options.paths?.length ? options.paths.map((p) => path18.resolve(root, p)) : [root]).filter(
-    (p) => fs16.existsSync(p)
+  const scopeAbs = (options.paths?.length ? options.paths.map((p) => path19.resolve(root, p)) : [root]).filter(
+    (p) => fs18.existsSync(p)
   );
   const found = /* @__PURE__ */ new Map();
   const consider = (abs) => {
     if (found.size >= maxFiles) return;
-    const rel2 = toPosix2(path18.relative(root, abs));
+    const rel2 = toPosix2(path19.relative(root, abs));
     if (!rel2 || rel2.startsWith("..")) return;
     if (rootIg.ignores(rel2)) return;
-    const base = path18.basename(abs);
+    const base = path19.basename(abs);
     if (SKIP_FILES.has(base.toLowerCase())) return;
     const category = classifyProjectContext(rel2);
     if (!category) return;
     try {
-      const st = fs16.statSync(abs);
+      const st = fs18.statSync(abs);
       if (!st.isFile() || st.size > DOC_FILE_MAX_BYTES) return;
       if (st.size === 0) return;
     } catch {
@@ -1718,14 +1719,14 @@ function discoverDocs(options) {
     if (found.size >= maxFiles || depth > 12) return;
     let entries;
     try {
-      entries = fs16.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
       if (found.size >= maxFiles) return;
-      const abs = path18.join(dir, entry.name);
-      const rel2 = toPosix2(path18.relative(root, abs));
+      const abs = path19.join(dir, entry.name);
+      const rel2 = toPosix2(path19.relative(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         if (rel2 && rootIg.ignores(`${rel2}/`) && !rel2.startsWith(".github")) continue;
@@ -1737,7 +1738,7 @@ function discoverDocs(options) {
   };
   for (const scope of scopeAbs) {
     try {
-      const st = fs16.statSync(scope);
+      const st = fs18.statSync(scope);
       if (st.isDirectory()) walk(scope, 0);
       else if (st.isFile()) consider(scope);
     } catch {
@@ -1748,7 +1749,7 @@ function discoverDocs(options) {
 function prepareDocBody(rel2, raw, category) {
   const scrubbed = redactSecrets(raw);
   if (scrubbed.length <= DOC_BODY_MAX_CHARS) return scrubbed;
-  if (category === "manifest" && path18.basename(rel2).toLowerCase() === "package.json") {
+  if (category === "manifest" && path19.basename(rel2).toLowerCase() === "package.json") {
     return summarizePackageJson(scrubbed);
   }
   if (category === "api-contract" && /\.(ya?ml|json)$/i.test(rel2)) {
@@ -1794,14 +1795,14 @@ function documentNodesFromDocs(docs) {
   for (const d of docs) {
     let raw = "";
     try {
-      raw = fs16.readFileSync(d.abs, "utf8");
+      raw = fs18.readFileSync(d.abs, "utf8");
     } catch {
       continue;
     }
     const category = d.category ?? d.kind;
     const scrubbed = prepareDocBody(d.rel, raw, category);
     if (!scrubbed.trim()) continue;
-    const name = path18.basename(d.rel);
+    const name = path19.basename(d.rel);
     const qualifiedName = d.rel.replace(/\\/g, "/");
     const id = nodeId({
       kind: "document",
@@ -1835,7 +1836,7 @@ function shardTsProjects(root, files) {
   const cache = /* @__PURE__ */ new Map();
   const byKey = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const dir = path18.dirname(f.abs);
+    const dir = path19.dirname(f.abs);
     const key = nearestProjectKey(root, dir, cache);
     const list = byKey.get(key);
     if (list) list.push(f);
@@ -1850,22 +1851,22 @@ function nearestProjectKey(root, startDir, cache) {
   const hit = cache.get(startDir);
   if (hit !== void 0) return hit;
   let dir = startDir;
-  const rootAbs = path18.resolve(root);
+  const rootAbs = path19.resolve(root);
   while (true) {
-    if (fs16.existsSync(path18.join(dir, "tsconfig.json")) || fs16.existsSync(path18.join(dir, "tsconfig.base.json")) || fs16.existsSync(path18.join(dir, "package.json"))) {
-      const key = toPosix3(path18.relative(rootAbs, dir)) || ".";
+    if (fs18.existsSync(path19.join(dir, "tsconfig.json")) || fs18.existsSync(path19.join(dir, "tsconfig.base.json")) || fs18.existsSync(path19.join(dir, "package.json"))) {
+      const key = toPosix3(path19.relative(rootAbs, dir)) || ".";
       cache.set(startDir, key);
       return key;
     }
-    if (dir === rootAbs || path18.dirname(dir) === dir) {
+    if (dir === rootAbs || path19.dirname(dir) === dir) {
       cache.set(startDir, ".");
       return ".";
     }
-    dir = path18.dirname(dir);
+    dir = path19.dirname(dir);
   }
 }
 function toPosix3(p) {
-  return p.split(path18.sep).join("/");
+  return p.split(path19.sep).join("/");
 }
 
 // src/engine/timing.ts
@@ -1900,11 +1901,284 @@ function nowMs() {
   return Number(process.hrtime.bigint() / 1000n) / 1e3;
 }
 
+// src/engine/summaries.ts
+var DEPEND_EDGES = /* @__PURE__ */ new Set(["call", "import", "extends", "implements", "references"]);
+var HUB_LIMIT = 40;
+function buildSummaries(graph) {
+  const index = indexFor(graph);
+  const candidates = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external" && n.kind !== "document").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, HUB_LIMIT);
+  const hubs = candidates.map((n) => {
+    const d1 = reverseDependents(index, n.id, 1);
+    const d2 = reverseDependents(index, n.id, 2);
+    const files = /* @__PURE__ */ new Set();
+    for (const id of d2) {
+      const node = index.node(id);
+      if (node?.file) files.add(node.file);
+    }
+    return {
+      id: n.id,
+      name: n.qualifiedName,
+      kind: n.kind,
+      file: n.file,
+      importance: n.importance,
+      direct: d1.size,
+      depth2: d2.size,
+      files: files.size,
+      tested: n.tested
+    };
+  });
+  hubs.sort((a, b) => b.importance - a.importance || a.name.localeCompare(b.name));
+  return { hubs };
+}
+function reverseDependents(index, rootId, maxDepth) {
+  const affected = /* @__PURE__ */ new Set();
+  let frontier = [rootId];
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    const next = [];
+    for (const id of frontier) {
+      for (const e of index.in(id)) {
+        if (!DEPEND_EDGES.has(e.kind)) continue;
+        if (e.src === rootId || affected.has(e.src)) continue;
+        affected.add(e.src);
+        next.push(e.src);
+      }
+    }
+    frontier = next;
+    if (frontier.length === 0) break;
+  }
+  return affected;
+}
+var emptyNode = (partial) => ({
+  ...partial,
+  span: partial.span ?? { start: 1, end: 1 },
+  importance: 0,
+  centrality: { degree: 0, pagerank: 0, betweenness: 0, eigenvector: 0 },
+  area: -1,
+  isHub: false,
+  tested: null
+});
+function extractManifests(root, opts = {}) {
+  const absRoot = path19.resolve(root);
+  const ig = buildRootIgnore3(absRoot, opts.exclude ?? []);
+  const scopes = (opts.paths?.length ? opts.paths : ["."]).map((p) => path19.resolve(absRoot, p)).filter((p) => fs18.existsSync(p));
+  const found = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    walkManifests(absRoot, scope, ig, found);
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  let deps = 0;
+  for (const rel2 of [...found.keys()].sort()) {
+    const abs = found.get(rel2);
+    const base = path19.posix.basename(rel2);
+    try {
+      if (base === "package.json") {
+        deps += ingestPackageJson(rel2, abs, nodes, edges);
+      } else if (base === "go.mod") {
+        deps += ingestGoMod(rel2, abs, nodes, edges);
+      }
+    } catch {
+    }
+  }
+  return {
+    nodes: [...nodes.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    edges: [...edges.values()].sort(
+      (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
+    ),
+    files: found.size,
+    deps
+  };
+}
+function ingestPackageJson(rel2, abs, nodes, edges) {
+  const raw = JSON.parse(fs18.readFileSync(abs, "utf8"));
+  const pkgName = raw.name && String(raw.name).trim() || path19.posix.dirname(rel2) || ".";
+  const localId = nodeId({ kind: "package", qualifiedName: pkgName, file: rel2 });
+  nodes.set(
+    localId,
+    emptyNode({
+      id: localId,
+      kind: "package",
+      name: pkgName.includes("/") ? pkgName.split("/").pop() : pkgName,
+      qualifiedName: pkgName,
+      file: rel2,
+      lang: "json"
+    })
+  );
+  const fileId = nodeId({ kind: "file", qualifiedName: rel2, file: rel2 });
+  nodes.set(
+    fileId,
+    emptyNode({
+      id: fileId,
+      kind: "file",
+      name: path19.posix.basename(rel2),
+      qualifiedName: rel2,
+      file: rel2,
+      lang: "json"
+    })
+  );
+  addEdge(edges, "contains", fileId, localId, 1);
+  let n = 0;
+  const depMaps = [raw.dependencies, raw.peerDependencies, raw.optionalDependencies];
+  const names = /* @__PURE__ */ new Set();
+  for (const m of depMaps) {
+    if (!m || typeof m !== "object") continue;
+    for (const name of Object.keys(m)) {
+      if (name) names.add(name);
+    }
+  }
+  for (const name of [...names].sort()) {
+    const extId = ensureExternal(nodes, name);
+    addEdge(edges, "import", localId, extId, 1);
+    n++;
+  }
+  return n;
+}
+function ingestGoMod(rel2, abs, nodes, edges) {
+  const text = fs18.readFileSync(abs, "utf8");
+  let moduleName = path19.posix.dirname(rel2) || ".";
+  const moduleMatch = /^\s*module\s+(\S+)/m.exec(text);
+  if (moduleMatch) moduleName = moduleMatch[1];
+  const localId = nodeId({ kind: "package", qualifiedName: moduleName, file: rel2 });
+  nodes.set(
+    localId,
+    emptyNode({
+      id: localId,
+      kind: "package",
+      name: moduleName.split("/").pop() ?? moduleName,
+      qualifiedName: moduleName,
+      file: rel2,
+      lang: "go"
+    })
+  );
+  const fileId = nodeId({ kind: "file", qualifiedName: rel2, file: rel2 });
+  nodes.set(
+    fileId,
+    emptyNode({
+      id: fileId,
+      kind: "file",
+      name: path19.posix.basename(rel2),
+      qualifiedName: rel2,
+      file: rel2,
+      lang: "go"
+    })
+  );
+  addEdge(edges, "contains", fileId, localId, 1);
+  const reqNames = /* @__PURE__ */ new Set();
+  const block = /require\s*\(([\s\S]*?)\)/g;
+  let bm;
+  while ((bm = block.exec(text)) !== null) {
+    for (const line of bm[1].split("\n")) {
+      const m = /^\s*(\S+)\s+v\S+/.exec(line);
+      if (m && !line.trim().startsWith("//")) reqNames.add(m[1]);
+    }
+  }
+  const single = /^\s*require\s+(\S+)\s+v\S+/gm;
+  let sm;
+  while ((sm = single.exec(text)) !== null) reqNames.add(sm[1]);
+  let n = 0;
+  for (const name of [...reqNames].sort()) {
+    const extId = ensureExternal(nodes, name);
+    addEdge(edges, "import", localId, extId, 1);
+    n++;
+  }
+  return n;
+}
+function ensureExternal(nodes, name) {
+  const id = nodeId({ kind: "external", qualifiedName: name, file: "" });
+  if (!nodes.has(id)) {
+    nodes.set(
+      id,
+      emptyNode({
+        id,
+        kind: "external",
+        name,
+        qualifiedName: name,
+        file: "",
+        lang: "external"
+      })
+    );
+  }
+  return id;
+}
+function addEdge(edges, kind, src, dst, confidence) {
+  if (src === dst) return;
+  const id = edgeId(kind, src, dst);
+  if (edges.has(id)) return;
+  edges.set(id, {
+    id,
+    kind,
+    src,
+    dst,
+    resolution: "heuristic",
+    confidence,
+    epistemic: "declared",
+    count: 1
+  });
+}
+function buildRootIgnore3(root, exclude) {
+  const ig = ignore();
+  const gitignorePath = path19.join(root, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) {
+    try {
+      ig.add(fs18.readFileSync(gitignorePath, "utf8"));
+    } catch {
+    }
+  }
+  if (exclude.length) ig.add(exclude);
+  return ig;
+}
+function walkManifests(root, dir, ig, found) {
+  let entries;
+  try {
+    entries = fs18.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const abs = path19.join(dir, entry.name);
+    const rel2 = path19.relative(root, abs).split(path19.sep).join("/");
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      if (rel2 && ig.ignores(`${rel2}/`)) continue;
+      walkManifests(root, abs, ig, found);
+    } else if (entry.isFile()) {
+      const base = entry.name;
+      if (base !== "package.json" && base !== "go.mod") continue;
+      if (rel2 && ig.ignores(rel2)) continue;
+      found.set(rel2, abs);
+    }
+  }
+}
+async function hashFilesParallel(jobs, concurrency) {
+  if (jobs.length === 0) return [];
+  const limit = Math.max(
+    1,
+    Math.min(concurrency ?? Math.max(1, (os.cpus()?.length ?? 4) * 2), jobs.length)
+  );
+  const out = new Array(jobs.length);
+  let next = 0;
+  async function worker() {
+    for (; ; ) {
+      const i = next++;
+      if (i >= jobs.length) return;
+      const job = jobs[i];
+      try {
+        const buf = await fs8.readFile(job.abs);
+        out[i] = { rel: job.rel, hash: hashBytes(buf), ok: true };
+      } catch {
+        out[i] = { rel: job.rel, hash: "", ok: false };
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: limit }, () => worker()));
+  return out;
+}
+
 // src/engine/build.ts
 async function buildGraph(options) {
   const timer = new StageTimer();
   timer.start("total");
-  const root = path18.resolve(options.root);
+  const root = path19.resolve(options.root);
   timer.start("discover");
   const files = discover({
     root,
@@ -1933,10 +2207,11 @@ async function buildGraph(options) {
   const reused = [];
   const buildWarnings = [];
   let statHits = 0;
+  const pendingHash = [];
   for (const file of files) {
     let stat;
     try {
-      stat = fs16.statSync(file.abs);
+      stat = fs18.statSync(file.abs);
     } catch {
       continue;
     }
@@ -1966,20 +2241,29 @@ async function buildGraph(options) {
       statHits++;
       continue;
     }
-    let hash = "";
-    try {
-      hash = hashBytes(fs16.readFileSync(file.abs));
-    } catch {
-      continue;
-    }
-    hashes.set(file.rel, hash);
-    fileStats.push({ rel: file.rel, size: stat.size, mtimeMs: stat.mtimeMs, hash });
-    const cached2 = cache.get(file.rel, hash);
-    if (cached2) {
-      reused.push(cached2);
-      cache.set(file.rel, cached2, { mtimeMs: stat.mtimeMs, size: stat.size });
-    } else {
-      toParse.push(file);
+    pendingHash.push({ file, size: stat.size, mtimeMs: stat.mtimeMs });
+  }
+  if (pendingHash.length) {
+    const jobs = pendingHash.map((p) => ({ rel: p.file.rel, abs: p.file.abs }));
+    const results = await hashFilesParallel(jobs, options.jobs);
+    const byRel = new Map(results.map((r) => [r.rel, r]));
+    for (const p of pendingHash) {
+      const r = byRel.get(p.file.rel);
+      if (!r || !r.ok) continue;
+      hashes.set(p.file.rel, r.hash);
+      fileStats.push({
+        rel: p.file.rel,
+        size: p.size,
+        mtimeMs: p.mtimeMs,
+        hash: r.hash
+      });
+      const cached2 = cache.get(p.file.rel, r.hash);
+      if (cached2) {
+        reused.push(cached2);
+        cache.set(p.file.rel, cached2, { mtimeMs: p.mtimeMs, size: p.size });
+      } else {
+        toParse.push(p.file);
+      }
     }
   }
   timer.end("hash");
@@ -2009,6 +2293,30 @@ async function buildGraph(options) {
   const resolved = resolve(parses, moduleResolver);
   timer.end("resolve");
   checkMemoryBudget("resolve", limits.memoryBudgetMb);
+  const manifests = extractManifests(root, {
+    exclude: options.exclude,
+    paths: options.paths
+  });
+  if (manifests.files > 0) {
+    const byId = new Map(resolved.nodes.map((n) => [n.id, n]));
+    for (const n of manifests.nodes) {
+      if (!byId.has(n.id)) {
+        byId.set(n.id, n);
+        resolved.nodes.push(n);
+      }
+    }
+    const edgeById = new Map(resolved.edges.map((e) => [e.id, e]));
+    for (const e of manifests.edges) {
+      if (!edgeById.has(e.id)) {
+        edgeById.set(e.id, e);
+        resolved.edges.push(e);
+      }
+    }
+    resolved.nodes.sort((a, b) => a.id.localeCompare(b.id));
+    resolved.edges.sort(
+      (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
+    );
+  }
   const nodeFileById = new Map(resolved.nodes.map((n) => [n.id, n.file]));
   let edges = resolved.edges;
   const resolvers = [...resolved.stats.resolvers];
@@ -2079,8 +2387,8 @@ async function buildGraph(options) {
   });
   for (const d of docs) {
     try {
-      const st = fs16.statSync(d.abs);
-      const hash = hashBytes(fs16.readFileSync(d.abs));
+      const st = fs18.statSync(d.abs);
+      const hash = hashBytes(fs18.readFileSync(d.abs));
       hashes.set(d.rel, hash);
       fileStats.push({ rel: d.rel, size: st.size, mtimeMs: st.mtimeMs, hash });
     } catch {
@@ -2121,7 +2429,7 @@ async function buildGraph(options) {
       toolchain
     },
     meta: {
-      root: path18.basename(root) === "" ? "." : ".",
+      root: path19.basename(root) === "" ? "." : ".",
       languages,
       analysisTier: analysis.tier,
       counts: {
@@ -2141,7 +2449,8 @@ async function buildGraph(options) {
   const survivingIds = new Set(analysis.nodes.map((n) => n.id));
   const unknowns = resolved.unresolved.filter((u) => !preciseCoveredFiles.has(u.fromRel) && survivingIds.has(u.from)).map((u) => ({ from: u.from, name: u.name, kind: u.kind, count: u.count }));
   if (unknowns.length) graph.unknowns = unknowns;
-  if (options.deep) {
+  graph.summaries = buildSummaries(graph);
+  {
     const facts = buildFacts(parses, analysis.nodes, analysis.edges);
     if (facts.length) graph.facts = facts;
   }
@@ -2179,14 +2488,14 @@ function toRepoRel(p) {
 function loadScipIndex(root, explicit) {
   const candidates = [
     explicit,
-    path18.join(root, "index.scip"),
-    path18.join(root, ".vibgrate", "index.scip")
+    path19.join(root, "index.scip"),
+    path19.join(root, ".vibgrate", "index.scip")
   ].filter((p) => Boolean(p));
   for (const file of candidates) {
-    const abs = path18.isAbsolute(file) ? file : path18.resolve(root, file);
-    if (!fs16.existsSync(abs)) continue;
+    const abs = path19.isAbsolute(file) ? file : path19.resolve(root, file);
+    if (!fs18.existsSync(abs)) continue;
     try {
-      const index = decodeScipIndex(new Uint8Array(fs16.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 };
       }
@@ -2301,21 +2610,21 @@ function usageError(message) {
 }
 var SNAPSHOT_VERSION = "vg-freshness/1";
 function snapshotPath(root) {
-  return path18.join(cacheDir(root), "freshness.json");
+  return path19.join(cacheDir(root), "freshness.json");
 }
 function writeSnapshot(root, corpusHash, fileStats, scope = {}) {
   const files = {};
   for (const f of fileStats) files[f.rel] = { size: f.size, mtimeMs: f.mtimeMs, hash: f.hash };
   const snapshot = { version: SNAPSHOT_VERSION, corpusHash, scope: pruneScope(scope), files };
   try {
-    fs16.mkdirSync(cacheDir(root), { recursive: true });
-    fs16.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(fs16.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 ?? {} };
     }
@@ -2335,7 +2644,14 @@ function probeFreshness(root) {
   const { scope } = snapshot;
   let discovered;
   try {
-    discovered = discover({ root, only: scope.only, exclude: scope.exclude, paths: scope.paths });
+    const code = discover({ root, only: scope.only, exclude: scope.exclude, paths: scope.paths });
+    const docs = discoverDocs({ root, exclude: scope.exclude, paths: scope.paths });
+    const byRel = /* @__PURE__ */ new Map();
+    for (const f of code) byRel.set(f.rel, f.abs);
+    for (const d of docs) {
+      if (!byRel.has(d.rel)) byRel.set(d.rel, d.abs);
+    }
+    discovered = [...byRel.entries()].map(([rel2, abs]) => ({ rel: rel2, abs })).sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
   } catch {
     return null;
   }
@@ -2351,15 +2667,25 @@ function probeFreshness(root) {
     }
     let stat;
     try {
-      stat = fs16.statSync(file.abs);
+      stat = fs18.statSync(file.abs);
     } catch {
       drift.removed.push(file.rel);
       continue;
     }
     if (stat.size === entry.size && stat.mtimeMs === entry.mtimeMs) continue;
+    if (entry.hash.startsWith("vg:oversize:")) {
+      const expected = `vg:oversize:${stat.size}`;
+      if (entry.hash === expected) {
+        snapshot.files[file.rel] = { size: stat.size, mtimeMs: stat.mtimeMs, hash: entry.hash };
+        absorbed = true;
+      } else {
+        drift.changed.push(file.rel);
+      }
+      continue;
+    }
     let hash = "";
     try {
-      hash = hashBytes(fs16.readFileSync(file.abs));
+      hash = hashBytes(fs18.readFileSync(file.abs));
     } catch {
       drift.removed.push(file.rel);
       continue;
@@ -2376,7 +2702,7 @@ function probeFreshness(root) {
   }
   if (absorbed && !hasDrift(drift)) {
     try {
-      fs16.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+      fs18.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
     } catch {
     }
   }
@@ -2422,6 +2748,30 @@ function shortestPath(graph, srcId, dstId) {
   if (reverse) return { ids: reverse.slice().reverse(), direction: "reverse" };
   return null;
 }
+var NEIGHBOR_CAP = 6;
+function pathDisconnect(graph, srcId, dstId) {
+  const idx = indexFor(graph);
+  const from = neighborhood(idx, srcId);
+  const to = neighborhood(idx, dstId);
+  const hint = from.calls.length || from.calledBy.length || to.calls.length || to.calledBy.length ? "No direct call/import chain links these symbols. Try `vg show` / `vg impact` on each end, or path via a shared hub." : "Neither endpoint has call/import neighbors in the map \u2014 they may be isolated docs/externals, or the link needs a more precise build.";
+  return { connected: false, from, to, hint };
+}
+function neighborhood(idx, id) {
+  const node = idx.node(id);
+  const name = node?.qualifiedName ?? id;
+  const calls = uniqueNames(idx.callees(id).map((x) => x.node.qualifiedName));
+  const calledBy = uniqueNames(idx.callers(id).map((x) => x.node.qualifiedName));
+  const imports = uniqueNames(
+    idx.out(id, "import").map((e) => idx.node(e.dst)?.qualifiedName).filter((n) => !!n)
+  );
+  const importedBy = uniqueNames(
+    idx.in(id, "import").map((e) => idx.node(e.src)?.qualifiedName).filter((n) => !!n)
+  );
+  return { name, calls, calledBy, imports, importedBy };
+}
+function uniqueNames(names) {
+  return [...new Set(names)].sort((a, b) => a.localeCompare(b)).slice(0, NEIGHBOR_CAP);
+}
 function coveringTests(graph, node, index) {
   const idx = index ?? indexFor(graph);
   const byId = idx.nodeById;
@@ -2457,10 +2807,10 @@ function testsToRun(graph, rootId, depth = 4) {
   };
 }
 function detectRunner(root, lang) {
-  const pkgPath = path18.join(root, "package.json");
-  if (fs16.existsSync(pkgPath)) {
+  const pkgPath = path19.join(root, "package.json");
+  if (fs18.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs16.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() };
@@ -2468,10 +2818,10 @@ function detectRunner(root, lang) {
     } catch {
     }
   }
-  if (lang === "py" || fs16.existsSync(path18.join(root, "pyproject.toml")) || fs16.existsSync(path18.join(root, "pytest.ini"))) {
+  if (lang === "py" || fs18.existsSync(path19.join(root, "pyproject.toml")) || fs18.existsSync(path19.join(root, "pytest.ini"))) {
     return { name: "pytest", command: (f) => `pytest ${f.join(" ")}`.trim() };
   }
-  if (lang === "go" || fs16.existsSync(path18.join(root, "go.mod"))) {
+  if (lang === "go" || fs18.existsSync(path19.join(root, "go.mod"))) {
     return { name: "go test", command: () => "go test ./..." };
   }
   if (lang === "cs" || hasFile(root, /\.csproj$/) || hasFile(root, /\.sln$/)) {
@@ -2482,16 +2832,16 @@ function detectRunner(root, lang) {
 }
 function hasFile(root, re) {
   try {
-    return fs16.readdirSync(root).some((f) => re.test(f));
+    return fs18.readdirSync(root).some((f) => re.test(f));
   } catch {
     return false;
   }
 }
 function findGitRoot(startDir = process.cwd()) {
-  let dir = path18.resolve(startDir);
+  let dir = path19.resolve(startDir);
   for (; ; ) {
-    if (fs16.existsSync(path18.join(dir, ".git"))) return dir;
-    const parent = path18.dirname(dir);
+    if (fs18.existsSync(path19.join(dir, ".git"))) return dir;
+    const parent = path19.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -2502,19 +2852,19 @@ function normalizeEntry(line) {
 function ensureGitignored(entry, startDir = process.cwd()) {
   const root = findGitRoot(startDir);
   if (!root) return { status: "not-a-repo", entry };
-  const gitignorePath = path18.join(root, ".gitignore");
+  const gitignorePath = path19.join(root, ".gitignore");
   const target = normalizeEntry(entry);
   let existing = "";
   let fileExisted = true;
   try {
-    existing = fs16.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");
-  fs16.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
+  fs18.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
 `, "utf8");
   return { status: fileExisted ? "added" : "created", entry, gitignorePath };
 }
@@ -2668,14 +3018,14 @@ dsnCommand.command("create").description("Create a new DSN token").option("--ing
     console.log(chalk.dim("The secret must be registered on your Vibgrate ingest API."));
   }
   if (opts.write) {
-    const writePath = path18.resolve(opts.write);
+    const writePath = path19.resolve(opts.write);
     await writeTextFile(writePath, dsn + "\n");
     console.log("");
     console.log(chalk.green("\u2714") + ` DSN written to ${opts.write}`);
-    const root = findGitRoot(path18.dirname(writePath));
-    const rel2 = root ? path18.relative(root, writePath).split(path18.sep).join("/") : "";
+    const root = findGitRoot(path19.dirname(writePath));
+    const rel2 = root ? path19.relative(root, writePath).split(path19.sep).join("/") : "";
     if (root && rel2 && !rel2.startsWith("..")) {
-      const res = ensureGitignored(rel2, path18.dirname(writePath));
+      const res = ensureGitignored(rel2, path19.dirname(writePath));
       if (res.status === "created") {
         console.log(chalk.green("\u2714") + ` Created .gitignore and ignored ${rel2}`);
       } else if (res.status === "added") {
@@ -2693,30 +3043,30 @@ dsnCommand.command("create").description("Create a new DSN token").option("--ing
 var STORE_DIRNAME = ".vibgrate";
 var STORE_FILENAME = "credentials.json";
 function homeCredentialsPath() {
-  return path18.join(os.homedir(), STORE_DIRNAME, STORE_FILENAME);
+  return path19.join(os.homedir(), STORE_DIRNAME, STORE_FILENAME);
 }
 function projectCredentialsPath(cwd = process.cwd()) {
   const root = findGitRoot(cwd) ?? cwd;
-  return path18.join(root, STORE_DIRNAME, STORE_FILENAME);
+  return path19.join(root, STORE_DIRNAME, STORE_FILENAME);
 }
 function credentialsPath(opts = {}) {
   const override = process.env.VIBGRATE_CREDENTIALS?.trim();
-  if (override) return path18.resolve(override);
+  if (override) return path19.resolve(override);
   const local = projectCredentialsPath(opts.cwd);
   if (opts.local) return local;
-  if (fs16.existsSync(local)) return local;
+  if (fs18.existsSync(local)) return local;
   return homeCredentialsPath();
 }
 function gitignoreEntryForCredentials(repoRoot, credsFile = credentialsPath()) {
-  const rel2 = path18.relative(repoRoot, credsFile);
-  if (rel2 && !rel2.startsWith("..") && !path18.isAbsolute(rel2)) {
-    return rel2.split(path18.sep).join("/");
+  const rel2 = path19.relative(repoRoot, credsFile);
+  if (rel2 && !rel2.startsWith("..") && !path19.isAbsolute(rel2)) {
+    return rel2.split(path19.sep).join("/");
   }
   return `${STORE_DIRNAME}/${STORE_FILENAME}`;
 }
 function readStoredCredentials(opts = {}) {
   try {
-    const raw = fs16.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 {
@@ -2725,16 +3075,16 @@ function readStoredCredentials(opts = {}) {
 }
 function writeStoredCredentials(creds, opts = {}) {
   const file = credentialsPath(opts);
-  fs16.mkdirSync(path18.dirname(file), { recursive: true });
-  fs16.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  fs18.mkdirSync(path19.dirname(file), { recursive: true });
+  fs18.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
   try {
-    fs16.chmodSync(file, 384);
+    fs18.chmodSync(file, 384);
   } catch {
   }
 }
 function clearStoredCredentials(opts = {}) {
   try {
-    fs16.rmSync(credentialsPath(opts));
+    fs18.rmSync(credentialsPath(opts));
     return true;
   } catch {
     return false;
@@ -3105,7 +3455,7 @@ var pushCommand = new Command("push").description("Push scan results to Vibgrate
     if (opts.strict) process.exit(1);
     return;
   }
-  const filePath = path18.resolve(opts.file);
+  const filePath = path19.resolve(opts.file);
   if (!await pathExists(filePath)) {
     console.error(chalk.red(`Scan artifact not found: ${filePath}`));
     console.error(chalk.dim('Run "vibgrate scan" first.'));
@@ -3200,7 +3550,7 @@ function measure(root, files) {
   for (const rel2 of files) {
     let size;
     try {
-      size = fs16.statSync(path18.join(root, rel2)).size;
+      size = fs18.statSync(path19.join(root, rel2)).size;
     } catch {
       continue;
     }
@@ -3223,9 +3573,9 @@ function matchLines(text, needleLower) {
 }
 function readCandidate(abs, knownSize) {
   try {
-    const size = knownSize ?? fs16.statSync(abs).size;
+    const size = knownSize ?? fs18.statSync(abs).size;
     if (size > MAX_FILE_BYTES) return null;
-    const text = fs16.readFileSync(abs, "utf8");
+    const text = fs18.readFileSync(abs, "utf8");
     return text.includes(NUL) ? null : text;
   } catch {
     return null;
@@ -3236,7 +3586,7 @@ function scanInline(root, files, needleLower, cap, stopAtCap, sizes) {
   let total = 0;
   let truncated = false;
   for (const rel2 of files) {
-    const text = readCandidate(path18.join(root, rel2), sizes?.get(rel2));
+    const text = readCandidate(path19.join(root, rel2), sizes?.get(rel2));
     if (text === null) continue;
     for (const h of matchLines(text, needleLower)) {
       total++;
@@ -3303,12 +3653,12 @@ var WORKER_SOURCE = [
   "parentPort.postMessage({ hits, total, truncated });"
 ].join("\n");
 function runWorker(root, files, needleLower) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const w = new Worker(WORKER_SOURCE, { eval: true, workerData: { root, files, needleLower } });
     let settled = false;
     w.once("message", (m) => {
       settled = true;
-      resolve12(m);
+      resolve13(m);
     });
     w.once("error", reject);
     w.once("exit", (code) => {
@@ -3377,10 +3727,10 @@ var BINARY_EXTS = /* @__PURE__ */ new Set([
   ".pdf"
 ]);
 function hasBinaryExt(rel2) {
-  return BINARY_EXTS.has(path18.extname(rel2).toLowerCase());
+  return BINARY_EXTS.has(path19.extname(rel2).toLowerCase());
 }
 function toPosix4(rel2) {
-  return path18.sep === "\\" ? rel2.replaceAll("\\", "/") : rel2;
+  return path19.sep === "\\" ? rel2.replaceAll("\\", "/") : rel2;
 }
 async function searchSymbols(graph, root, query, limit) {
   let q = query.trim();
@@ -3519,13 +3869,13 @@ function walkCandidates(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs16.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 = path18.join(dir, e.name);
+      const abs = path19.join(dir, e.name);
       if (e.isDirectory()) {
         stack.push(abs);
         continue;
@@ -3535,7 +3885,7 @@ function walkCandidates(root) {
         truncated = true;
         continue;
       }
-      files.push(toPosix4(path18.relative(root, abs)));
+      files.push(toPosix4(path19.relative(root, abs)));
     }
   }
   files.sort();
@@ -3566,12 +3916,12 @@ 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, sep9 = path18.sep) {
+function parseRgFileList(stdout, sep10 = path19.sep) {
   const seen = /* @__PURE__ */ new Set();
   for (const raw of stdout.split("\n")) {
     if (!raw) continue;
-    const posix = sep9 === "\\" ? raw.replaceAll("\\", "/") : raw;
-    const rel2 = posix.startsWith("./") ? posix.slice(2) : posix;
+    const posix2 = sep10 === "\\" ? raw.replaceAll("\\", "/") : raw;
+    const rel2 = posix2.startsWith("./") ? posix2.slice(2) : posix2;
     if (!rel2) continue;
     const segs = rel2.split("/");
     if (segs.some((s) => s.startsWith(".") || IGNORE_DIRS.has(s))) continue;
@@ -3582,8 +3932,8 @@ function parseRgFileList(stdout, sep9 = path18.sep) {
 }
 function readScanArtifact(root) {
   try {
-    const file = path18.join(root, ".vibgrate", "scan_result.json");
-    return JSON.parse(fs16.readFileSync(file, "utf8"));
+    const file = path19.join(root, ".vibgrate", "scan_result.json");
+    return JSON.parse(fs18.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -3839,6 +4189,12 @@ ${chunk2}`);
 }
 
 // src/engine/quality.ts
+var IDENT_RE = /^(?:[A-Za-z][a-z0-9]*[A-Z][A-Za-z0-9]*|[a-z][a-z0-9]*(?:_[a-z0-9]+)+|[a-z][a-z0-9]*(?:-[a-z0-9]+)+)$/;
+function identifierTerms(query) {
+  if (!query) return [];
+  const raw = [...new Set(query.split(/[^A-Za-z0-9_-]+/).filter((w) => w.length > 2))];
+  return raw.filter((t) => IDENT_RE.test(t) || t.length >= 6 && /[A-Z]/.test(t) && /[a-z]/.test(t));
+}
 function assessDocQuality(content, opts = {}) {
   const minTokens = opts.minTokens ?? 60;
   const lc = content.toLowerCase();
@@ -3856,20 +4212,36 @@ function assessDocQuality(content, opts = {}) {
     else reasons.push("library name absent");
   }
   const qt = tokenizeQuery(opts.query);
+  const idents = identifierTerms(opts.query);
   let onTopic = qt.length === 0;
   if (qt.length) {
-    const hits = qt.filter((t) => lc.includes(t)).length;
-    if (hits) {
-      score += Math.min(hits, 2);
-      onTopic = true;
+    const missingIdents = idents.filter((id) => !lc.includes(id.toLowerCase()));
+    if (missingIdents.length) {
+      reasons.push(`API symbol(s) absent: ${missingIdents.join(", ")}`);
+      onTopic = false;
     } else {
-      reasons.push("query terms absent");
+      const hits = qt.filter((t) => lc.includes(t)).length;
+      const need = Math.max(1, Math.floor(qt.length / 2) + 1);
+      if (hits >= need) {
+        score += Math.min(hits, 2);
+        onTopic = true;
+      } else {
+        reasons.push(hits === 0 ? "query terms absent" : `query terms weak (${hits}/${qt.length})`);
+        onTopic = false;
+      }
     }
   }
   if (opts.symbols?.length) {
     if (opts.symbols.some((s) => s.length > 2 && lc.includes(s.toLowerCase()))) score += 1;
     else reasons.push("no API symbols present");
   }
+  if (opts.readmeOnly && (idents.length > 0 || qt.length >= 2)) {
+    onTopic = false;
+    if (!reasons.includes("README-only source cannot answer a focused API query")) {
+      reasons.push("README-only source cannot answer a focused API query");
+    }
+    score = Math.min(score, 4);
+  }
   const sufficient = hasCode && tokens >= minTokens && onTopic;
   return { score, sufficient, reasons };
 }
@@ -3973,7 +4345,7 @@ var CACHE_VERSION = "vg-hosted-docs/1";
 var HOSTED_DOCS_TTL_MS = 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES = 64;
 function cachePath(root) {
-  return path18.join(cacheDir(root), "hosted-docs.json");
+  return path19.join(cacheDir(root), "hosted-docs.json");
 }
 function hostedDocsCacheKey(req, opts = {}) {
   const material = JSON.stringify([
@@ -3989,7 +4361,7 @@ function hostedDocsCacheKey(req, opts = {}) {
 }
 function loadFile(root) {
   try {
-    const parsed = JSON.parse(fs16.readFileSync(cachePath(root), "utf8"));
+    const parsed = JSON.parse(fs18.readFileSync(cachePath(root), "utf8"));
     if (parsed && parsed.version === CACHE_VERSION && parsed.entries && typeof parsed.entries === "object") return parsed;
   } catch {
   }
@@ -4003,8 +4375,8 @@ function saveFile(root, file) {
         delete file.entries[k];
       }
     }
-    fs16.mkdirSync(cacheDir(root), { recursive: true });
-    fs16.writeFileSync(cachePath(root), JSON.stringify(file));
+    fs18.mkdirSync(cacheDir(root), { recursive: true });
+    fs18.writeFileSync(cachePath(root), JSON.stringify(file));
   } catch {
   }
 }
@@ -4292,11 +4664,11 @@ var TOOLS = [
         area: node.area
       };
       if (ctx?.dedup && ctx.seen?.has(node.id)) {
-        return { ...base, repeat: true, callsTotal: uniqueNames(calleeRecs.map((x) => x.node.qualifiedName)).length, calledByTotal: uniqueNames(callerRecs.map((x) => x.node.qualifiedName)).length };
+        return { ...base, repeat: true, callsTotal: uniqueNames2(calleeRecs.map((x) => x.node.qualifiedName)).length, calledByTotal: uniqueNames2(callerRecs.map((x) => x.node.qualifiedName)).length };
       }
       const edgeCap = isDetailed(args) ? NODE_EDGE_CAP : CONCISE_MATCHES;
-      const calls = boundList(uniqueNames(calleeRecs.map((x) => x.node.qualifiedName)), edgeCap);
-      const calledBy = boundList(uniqueNames(callerRecs.map((x) => x.node.qualifiedName)), edgeCap);
+      const calls = boundList(uniqueNames2(calleeRecs.map((x) => x.node.qualifiedName)), edgeCap);
+      const calledBy = boundList(uniqueNames2(callerRecs.map((x) => x.node.qualifiedName)), edgeCap);
       ctx?.seen?.add(node.id);
       return {
         ...base,
@@ -4325,7 +4697,7 @@ var TOOLS = [
       if (!ra.node) return { endpoint: "a", ...unresolved(ra.candidates) };
       if (!rb.node) return { endpoint: "b", ...unresolved(rb.candidates) };
       const result = shortestPath(graph, ra.node.id, rb.node.id);
-      if (!result) return { connected: false };
+      if (!result) return pathDisconnect(graph, ra.node.id, rb.node.id);
       const byId = new Map(graph.nodes.map((n) => [n.id, n]));
       return { connected: true, direction: result.direction, path: result.ids.map((id) => byId.get(id)?.qualifiedName ?? id) };
     }
@@ -4418,27 +4790,68 @@ var TOOLS = [
   },
   {
     name: "list_hubs",
-    description: "Most-depended-on symbols.",
+    description: "Most-depended-on symbols (includes precomputed blast-radius counts when available).",
     inputSchema: obj({ limit: { type: "number" } }),
-    handler: (graph, args) => graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance).slice(0, numOr(args.limit, 20)).map((n) => ({ name: n.qualifiedName, kind: n.kind, file: n.file, line: n.span.start, importance: n.importance, isHub: n.isHub }))
+    handler: (graph, args) => {
+      const limit = numOr(args.limit, 20);
+      if (graph.summaries?.hubs?.length) {
+        return graph.summaries.hubs.slice(0, limit).map((h) => ({
+          name: h.name,
+          kind: h.kind,
+          file: h.file,
+          importance: h.importance,
+          isHub: true,
+          directDependents: h.direct,
+          depth2Dependents: h.depth2,
+          filesAffected: h.files,
+          tested: h.tested
+        }));
+      }
+      return graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance).slice(0, limit).map((n) => ({
+        name: n.qualifiedName,
+        kind: n.kind,
+        file: n.file,
+        line: n.span.start,
+        importance: n.importance,
+        isHub: n.isHub
+      }));
+    }
   },
   {
     name: "get_facts",
-    description: "Deterministic facts for a node (contract/invariant); needs a --deep build.",
-    inputSchema: obj({ name: { type: "string" } }, ["name"]),
+    description: "Deterministic facts for a node (contract / invariant / characterization).",
+    inputSchema: obj(
+      {
+        name: { type: "string" },
+        pick: { type: "number", description: "nth candidate if ambiguous" }
+      },
+      ["name"]
+    ),
     handler: (graph, args) => {
-      const { node, candidates } = resolveOne(graph, String(args.name ?? ""));
+      const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
       if (!node) return unresolved(candidates);
-      if (!graph.facts) return { node: node.qualifiedName, facts: [], note: "facts require a --deep build" };
+      if (!graph.facts) {
+        return {
+          node: node.qualifiedName,
+          facts: [],
+          note: "map has no facts \u2014 rebuild with a current vg (facts ship on every build)"
+        };
+      }
       return { node: node.qualifiedName, facts: graph.facts.filter((f) => f.subjectIds.includes(node.id)) };
     }
   },
   {
     name: "guide_node",
     description: "Cited standards/practices for a node (OWASP/CWE).",
-    inputSchema: obj({ name: { type: "string" } }, ["name"]),
+    inputSchema: obj(
+      {
+        name: { type: "string" },
+        pick: { type: "number", description: "nth candidate if ambiguous" }
+      },
+      ["name"]
+    ),
     handler: (graph, args) => {
-      const { node, candidates } = resolveOne(graph, String(args.name ?? ""));
+      const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
       if (!node) return unresolved(candidates);
       const entries = new Map(FREE_PACK.entries.map((e) => [e.id, e]));
       return {
@@ -4632,13 +5045,24 @@ var TOOLS = [
       const verbosity = ["concise", "balanced", "exhaustive"].includes(String(args.verbosity)) ? String(args.verbosity) : query ? "concise" : "balanced";
       const budget = numOrU(args.max_tokens) ?? numOrU(args.tokens) ?? VERBOSITY_BUDGET[verbosity];
       const ver = resolveVersion(ctx.root, id);
-      const render = (readme, libName) => {
-        const apiSurface = localApiSurface(ctx.root, libName);
-        const sel = selectForBudget({ readme, query, apiSurface, budget });
-        const quality = assessDocQuality([readme, apiSurface].filter(Boolean).join("\n\n"), {
+      const focusQuery = (() => {
+        const q = query.trim();
+        if (!q) return q;
+        const bare = id.replace(/^@[^/]+\//, "").toLowerCase();
+        const parts = q.split(/\s+/);
+        if (parts.length > 1 && parts[0].toLowerCase().replace(/^@[^/]+\//, "") === bare) {
+          return parts.slice(1).join(" ");
+        }
+        return q;
+      })();
+      const render = (readme, libName, readmeOnly) => {
+        const apiSurface = localApiSurface(ctx.root, libName, focusQuery || void 0);
+        const sel = selectForBudget({ readme, query: focusQuery || query, apiSurface, budget });
+        const quality = assessDocQuality(sel.text, {
           name: libName,
-          query,
-          symbols: symbolsFromApi(apiSurface)
+          query: focusQuery || query || void 0,
+          symbols: symbolsFromApi(apiSurface),
+          readmeOnly: readmeOnly === true && !apiSurface
         });
         return {
           content: sel.text,
@@ -4655,7 +5079,7 @@ var TOOLS = [
       let answer = null;
       let sufficient = false;
       if (entry) {
-        const r = render(readDoc(ctx.root, entry), entry.name);
+        const r = render(readDoc(ctx.root, entry), entry.name, false);
         sufficient = r.metadata.quality.sufficient;
         answer = {
           targetId: entry.id,
@@ -4670,9 +5094,9 @@ var TOOLS = [
           metadata: r.metadata
         };
       } else {
-        const local = localPackageDocs(ctx.root, id);
+        const local = localPackageDocs(ctx.root, id, { query: focusQuery || query || void 0 });
         if (local) {
-          const r = render(local.docs, id);
+          const r = render(local.docs, id, local.readmeOnly);
           sufficient = r.metadata.quality.sufficient;
           answer = {
             targetId: id,
@@ -4721,14 +5145,22 @@ function conciseSummary(graph) {
   return { counts: graph.meta.counts, languages: graph.meta.languages };
 }
 function summarize(graph, top = 10) {
+  const topHubs = graph.summaries?.hubs?.length ? graph.summaries.hubs.slice(0, top).map((h) => ({
+    name: h.name,
+    file: h.file,
+    importance: h.importance,
+    directDependents: h.direct,
+    depth2Dependents: h.depth2
+  })) : graph.nodes.filter((n) => n.isHub).sort((a, b) => b.importance - a.importance).slice(0, top).map((n) => ({ name: n.qualifiedName, file: n.file, importance: n.importance }));
   return {
     counts: graph.meta.counts,
     languages: graph.meta.languages,
     cluster: graph.meta.cluster,
+    analysisTier: graph.meta.analysisTier ?? "full",
     resolver: graph.provenance.resolver,
     generatedAt: graph.generatedAt,
     topAreas: [...graph.areas].sort((a, b) => b.size - a.size).slice(0, top).map((a) => ({ id: a.id, label: a.label, size: a.size })),
-    topHubs: graph.nodes.filter((n) => n.isHub).sort((a, b) => b.importance - a.importance).slice(0, top).map((n) => ({ name: n.qualifiedName, file: n.file, importance: n.importance }))
+    topHubs
   };
 }
 function stripId(item) {
@@ -4756,7 +5188,7 @@ function numOrU(v) {
   const n = Number(v);
   return Number.isFinite(n) ? n : void 0;
 }
-function uniqueNames(xs) {
+function uniqueNames2(xs) {
   return [...new Set(xs)];
 }
 var HOT_TOOLS = ["orient", "search_symbols", "query_graph", "get_node"];
@@ -4979,12 +5411,12 @@ function detectAssistants(root, opts = {}) {
   const which = opts.which ?? whichOnPath;
   const found = [];
   for (const assistant of ASSISTANTS) {
-    const repoHit = (assistant.markers ?? []).find((m) => fs16.existsSync(path18.join(root, m)));
+    const repoHit = (assistant.markers ?? []).find((m) => fs18.existsSync(path19.join(root, m)));
     if (repoHit) {
       found.push({ assistant, via: "repo", marker: repoHit });
       continue;
     }
-    const homeHit = (assistant.homeMarkers ?? []).find((m) => fs16.existsSync(path18.join(home, m)));
+    const homeHit = (assistant.homeMarkers ?? []).find((m) => fs18.existsSync(path19.join(home, m)));
     if (homeHit) {
       found.push({ assistant, via: "home", marker: homeHit });
       continue;
@@ -5016,19 +5448,19 @@ function installAssistant(a, opts) {
   const skipped = [];
   let note;
   if (a.skill) {
-    writeFileEnsured(path18.join(opts.root, a.skill), skillMarkdown(a.id));
+    writeFileEnsured(path19.join(opts.root, a.skill), skillMarkdown(a.id));
     wrote.push(a.skill);
   }
   if (a.mcp) {
     const launch = opts.launch ?? detectServeLaunch();
-    upsertMcp(path18.join(opts.root, a.mcp.file), a.mcp, launch);
+    upsertMcp(path19.join(opts.root, a.mcp.file), a.mcp, launch);
     wrote.push(a.mcp.file);
     note = launch.note;
   } else {
     skipped.push("mcp (host-specific setup)");
   }
   if (a.nudge && opts.hook !== false) {
-    writeNudge(path18.join(opts.root, a.nudge.file), a.nudge, opts.smallRepo, a.id);
+    writeNudge(path19.join(opts.root, a.nudge.file), a.nudge, opts.smallRepo, a.id);
     wrote.push(a.nudge.file);
   } else if (a.nudge) {
     skipped.push("nudge (--no-hook)");
@@ -5038,41 +5470,41 @@ function installAssistant(a, opts) {
 function uninstallAssistant(a, root, purge) {
   const removed = [];
   if (a.mcp) {
-    const file = path18.join(root, a.mcp.file);
+    const file = path19.join(root, a.mcp.file);
     if (removeMcp(file, a.mcp)) removed.push(a.mcp.file);
   }
   if (a.nudge) {
-    const file = path18.join(root, a.nudge.file);
+    const file = path19.join(root, a.nudge.file);
     if (a.nudge.kind === "block") {
       if (removeBlock(file)) removed.push(a.nudge.file);
-    } else if (fs16.existsSync(file)) {
-      fs16.rmSync(file);
+    } else if (fs18.existsSync(file)) {
+      fs18.rmSync(file);
       removed.push(a.nudge.file);
     }
   }
   if (purge && a.skill) {
-    const file = path18.join(root, a.skill);
-    if (fs16.existsSync(file)) {
-      fs16.rmSync(file);
+    const file = path19.join(root, a.skill);
+    if (fs18.existsSync(file)) {
+      fs18.rmSync(file);
       removed.push(a.skill);
     }
   }
   return removed;
 }
 function writeFileEnsured(file, content) {
-  fs16.mkdirSync(path18.dirname(file), { recursive: true });
-  fs16.writeFileSync(file, content);
+  fs18.mkdirSync(path19.dirname(file), { recursive: true });
+  fs18.writeFileSync(file, content);
 }
 function writeNavigationConfig(root) {
   ensureVibgrateGitignore(root);
-  const rel2 = path18.join(".vibgrate", "mcp-navigation.json");
+  const rel2 = path19.join(".vibgrate", "mcp-navigation.json");
   const doc = {
     _readme: "Deferred-loading config for agents embedding `vg serve` via the Claude API (defer_loading + tool-search). The hot navigation core stays in context; the rest load on demand \u2014 ~350-450 schema tokens/step vs ~1,881 for the full set. Hosts without defer_loading ignore this and serve the whole (already optimized) tool set. See docs/graph/VG-NAVIGATION-PROFILE.md.",
     hot_core: [...HOT_TOOLS],
     deferred: deferredToolNames(),
     toolset: navigationToolsetConfig()
   };
-  writeFileEnsured(path18.join(root, rel2), `${JSON.stringify(doc, null, 2)}
+  writeFileEnsured(path19.join(root, rel2), `${JSON.stringify(doc, null, 2)}
 `);
   return rel2;
 }
@@ -5087,7 +5519,7 @@ function upsertMcp(file, target, launch) {
 `);
 }
 function removeMcp(file, target) {
-  if (!fs16.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;
@@ -5106,8 +5538,8 @@ function refreshInstalledInstructions(root, smallRepo) {
   };
   for (const a of ASSISTANTS) {
     if (a.skill) {
-      const file = path18.join(root, a.skill);
-      if (fs16.existsSync(file)) {
+      const file = path19.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) {
@@ -5117,8 +5549,8 @@ function refreshInstalledInstructions(root, smallRepo) {
       }
     }
     if (a.nudge) {
-      const file = path18.join(root, a.nudge.file);
-      if (!fs16.existsSync(file)) continue;
+      const file = path19.join(root, a.nudge.file);
+      if (!fs18.existsSync(file)) continue;
       const text = readTextSafe(file);
       if (text === null) continue;
       if (a.nudge.kind === "block") {
@@ -5142,7 +5574,7 @@ function refreshInstalledInstructions(root, smallRepo) {
 }
 function readTextSafe(file) {
   try {
-    return fs16.readFileSync(file, "utf8");
+    return fs18.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -5161,8 +5593,8 @@ ${stripMarkers(nudgeMarkdown(smallRepo, client))}` : stripMarkers(nudgeMarkdown(
   upsertBlock(file, nudgeMarkdown(smallRepo, client));
 }
 function upsertBlock(file, block) {
-  fs16.mkdirSync(path18.dirname(file), { recursive: true });
-  let existing = fs16.existsSync(file) ? fs16.readFileSync(file, "utf8") : "";
+  fs18.mkdirSync(path19.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*$/, "")}
@@ -5170,20 +5602,20 @@ function upsertBlock(file, block) {
 ${block}
 ` : `${block}
 `;
-  fs16.writeFileSync(file, existing);
+  fs18.writeFileSync(file, existing);
 }
 function removeBlock(file) {
-  if (!fs16.existsSync(file)) return false;
-  const existing = fs16.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;
-  fs16.writeFileSync(file, existing.replace(re, "\n"));
+  fs18.writeFileSync(file, existing.replace(re, "\n"));
   return true;
 }
 function readJson(file) {
-  if (!fs16.existsSync(file)) return {};
+  if (!fs18.existsSync(file)) return {};
   try {
-    const parsed = JSON.parse(fs16.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -5203,7 +5635,7 @@ function escapeRe(s) {
 }
 var REFRESH_LOCK_STALE_MS = 10 * 60 * 1e3;
 function refreshLockPath(root) {
-  return path18.join(cacheDir(root), "refresh.lock");
+  return path19.join(cacheDir(root), "refresh.lock");
 }
 async function refreshIfStale(root, opts = {}) {
   const probe = probeFreshness(root);
@@ -5235,8 +5667,8 @@ async function refreshIfStale(root, opts = {}) {
       writeArtifacts(result.graph, {
         root,
         graphPath: opts.graphPath,
-        report: fs16.existsSync(path18.join(dir, "GRAPH_REPORT.md")),
-        html: fs16.existsSync(path18.join(dir, "graph.html"))
+        report: fs18.existsSync(path19.join(dir, "GRAPH_REPORT.md")),
+        html: fs18.existsSync(path19.join(dir, "graph.html"))
       });
     }
     writeSnapshot(root, result.graph.provenance.corpusHash, result.fileStats, scope);
@@ -5256,6 +5688,6 @@ async function refreshIfStale(root, opts = {}) {
   }
 }
 
-export { ASSISTANTS, CliError, ExitCode, FREE_PACK, NPX_INVOCATION, ResourceLimitError, SKIP_DIRS, SKIP_FILES, SMALL_REPO_FILES, TOOLS, UsageError, analyze, applyCoverage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, clearStoredCredentials, countTokens, coveringTests, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, detectAssistants, detectRunner, detectServeLaunch, discover, driftCount, dsnCommand, ensureGitignored, epistemicBreakdown, fetchHostedDocsCached, findGitRoot, gitignoreEntryForCredentials, groundGraph, hasDrift, homeCredentialsPath, hostedBase, ingestHostForRegionId, installAssistant, loadCoverage, loadSnapshot, parseDsn, probeFreshness, projectCredentialsPath, publishPrivateLibrary, pushCommand, readScanArtifact, readStoredCredentials, refreshIfStale, refreshInstalledInstructions, renderToolResult, resolveCliInvocation, resolveDsn, resolveIngestHost, resolveLimits, scipEdges, searchSymbols, selectForBudget, shortestPath, symbolsFromApi, testsToRun, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, warmEmbedderInBackground, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
-//# sourceMappingURL=chunk-KNELIQJO.js.map
-//# sourceMappingURL=chunk-KNELIQJO.js.map
+export { ASSISTANTS, CliError, ExitCode, FREE_PACK, NPX_INVOCATION, ResourceLimitError, SKIP_DIRS, SKIP_FILES, SMALL_REPO_FILES, TOOLS, UsageError, analyze, applyCoverage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, clearStoredCredentials, countTokens, coveringTests, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, detectAssistants, detectRunner, detectServeLaunch, discover, driftCount, dsnCommand, ensureGitignored, epistemicBreakdown, fetchHostedDocsCached, findGitRoot, gitignoreEntryForCredentials, groundGraph, hasDrift, homeCredentialsPath, hostedBase, ingestHostForRegionId, installAssistant, loadCoverage, loadSnapshot, parseDsn, pathDisconnect, probeFreshness, projectCredentialsPath, publishPrivateLibrary, pushCommand, readScanArtifact, readStoredCredentials, refreshIfStale, refreshInstalledInstructions, renderToolResult, resolveCliInvocation, resolveDsn, resolveIngestHost, resolveLimits, scipEdges, searchSymbols, selectForBudget, shortestPath, symbolsFromApi, testsToRun, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, warmEmbedderInBackground, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
+//# sourceMappingURL=chunk-YKVH2PGF.js.map
+//# sourceMappingURL=chunk-YKVH2PGF.js.map