@vibgrate/cli 2026.727.1 → 2026.727.3

package/dist/{chunk-S6CYDZEW.js → chunk-MAY5HLDH.js}

@@ -1,17 +1,17 @@
-import { loadConfig, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-WLETRGAC.js';
-import { resolveVersion, resolveLib, loadCatalog, driftFor, localPackageDocs, readDoc, inventory, localApiSurface, edgeId, buildModuleResolver, resolve, applyStaticTestLinkage, nodeId } from './chunk-C4CKTAZP.js';
+import { resolveVersion, resolveLib, loadCatalog, driftFor, localPackageDocs, readDoc, inventory, localApiSurface, edgeId, buildModuleResolver, resolve, applyStaticTestLinkage, nodeId } from './chunk-6JIKUDWM.js';
+import { loadConfig, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-Y23HMSWU.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, cacheDir, loadCache, acquireLock, releaseLock } from './chunk-6IOQJGFT.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 { langById, grammarSetVersion, langForExtension, setGrammarsOverride, parseSource } from './chunk-ON25BX6T.js';
 import { redactSecrets } from './chunk-RXP66R2E.js';
-import { loadGraph, ensureVibgrateGitignore, vibgrateDir, writeArtifacts } from './chunk-HABUT7HW.js';
-import { serializeGraph, stableStringify } from './chunk-5Q54GEHM.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 fs15 from 'fs';
+import * as fs18 from 'fs';
 import { spawnSync, execFileSync } from 'child_process';
-import * as path17 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 = fs15.realpathSync(binPath);
+    const real = fs18.realpathSync(binPath);
     if (/[\\/]@vibgrate[\\/]cli[\\/]/.test(real)) return true;
-    const head = fs15.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(fs15.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(path17.sep).join("/");
+  return p.split(path19.sep).join("/");
 }
 function buildRootIgnore(root, exclude) {
   const ig = ignore();
-  const gitignorePath = path17.join(root, ".gitignore");
-  if (fs15.existsSync(gitignorePath)) {
-    ig.add(fs15.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 = path17.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) => path17.resolve(root, p)) : [root]).filter((p) => fs15.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(path17.relative(root, abs));
+    const rel2 = toPosix(path19.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(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 = fs15.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 = 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 = fs15.statSync(scope);
+    const stat = fs18.statSync(scope);
     if (stat.isDirectory()) walk(scope);
     else if (stat.isFile()) considerFile(scope);
   }
@@ -540,25 +541,36 @@ function mulberry32(seed) {
 var CLUSTER_SEED = 42;
 
 // src/engine/analyze.ts
+var TIER_LARGE_NODES = 5e3;
+var TIER_XL_NODES = 5e4;
+function pickAnalysisTier(nodeCount, forced) {
+  if (forced) return forced;
+  if (nodeCount > TIER_XL_NODES) return "xl";
+  if (nodeCount > TIER_LARGE_NODES) return "large";
+  return "full";
+}
 var DEP_EDGES = /* @__PURE__ */ new Set(["call", "import", "extends", "implements", "references"]);
 var CLUSTER_EDGE_KINDS = /* @__PURE__ */ new Set([...DEP_EDGES, "contains"]);
 var IMPORTANCE_WEIGHTS = { pagerank: 0.4, betweenness: 0.25, eigenvector: 0.2, degree: 0.15 };
 var DEFAULT_BETWEENNESS_LIMIT = 5e3;
 function analyze(nodes, edges, options = {}) {
-  const mode = options.cluster ?? "louvain";
+  const tier = pickAnalysisTier(nodes.length, options.tier);
+  const mode = options.cluster ?? (tier === "xl" ? "louvain" : "louvain");
   const ids = [...nodes.map((n) => n.id)].sort((a, b) => a.localeCompare(b));
   const dg = simpleGraph(ids, edges, DEP_EDGES, "directed");
   const pr = safeMetric(() => pagerank(dg), ids);
-  const bw = dg.order <= (options.betweennessLimit ?? DEFAULT_BETWEENNESS_LIMIT) ? safeMetric(() => betweenness(dg), ids) : zeros(ids);
-  const ev = safeMetric(() => eigenvector(dg), ids);
+  const bwLimit = options.betweennessLimit ?? DEFAULT_BETWEENNESS_LIMIT;
+  const bw = tier === "full" && dg.order <= bwLimit ? safeMetric(() => betweenness(dg), ids) : zeros(ids);
+  const ev = tier === "full" || tier === "large" ? safeMetric(() => eigenvector(dg), ids) : zeros(ids);
   const deg = degreeMap(dg, ids);
   const prN = normalize(pr);
   const bwN = normalize(bw);
   const evN = normalize(ev);
   const degN = normalize(deg);
+  const weights = tier === "xl" ? { pagerank: 0.7, betweenness: 0, eigenvector: 0, degree: 0.3 } : tier === "large" ? { pagerank: 0.5, betweenness: 0, eigenvector: 0.25, degree: 0.25 } : IMPORTANCE_WEIGHTS;
   const importance = /* @__PURE__ */ new Map();
   for (const id of ids) {
-    const score = IMPORTANCE_WEIGHTS.pagerank * (prN.get(id) ?? 0) + IMPORTANCE_WEIGHTS.betweenness * (bwN.get(id) ?? 0) + IMPORTANCE_WEIGHTS.eigenvector * (evN.get(id) ?? 0) + IMPORTANCE_WEIGHTS.degree * (degN.get(id) ?? 0);
+    const score = weights.pagerank * (prN.get(id) ?? 0) + weights.betweenness * (bwN.get(id) ?? 0) + weights.eigenvector * (evN.get(id) ?? 0) + weights.degree * (degN.get(id) ?? 0);
     importance.set(id, score);
   }
   const importanceN = normalize(importance);
@@ -567,7 +579,7 @@ function analyze(nodes, edges, options = {}) {
   const variance = vals.reduce((a, b) => a + (b - mean) ** 2, 0) / (vals.length || 1);
   const std = Math.sqrt(variance);
   const hubThreshold = mean + 2 * std;
-  const { areaByNode, mode: actualMode } = cluster(ids, edges, mode);
+  const { areaByNode, mode: actualMode } = tier === "xl" ? clusterFileLevel(nodes, edges, mode) : cluster(ids, edges, mode);
   const outNodes = nodes.map((n) => ({
     ...n,
     centrality: {
@@ -582,7 +594,42 @@ function analyze(nodes, edges, options = {}) {
   })).sort((a, b) => a.id.localeCompare(b.id));
   const areas = buildAreas(outNodes, edges, areaByNode);
   const outEdges = scoreSurprise(edges, areaByNode);
-  return { nodes: outNodes, edges: outEdges, areas, cluster: actualMode };
+  return { nodes: outNodes, edges: outEdges, areas, cluster: actualMode, tier };
+}
+function clusterFileLevel(nodes, edges, mode) {
+  const fileNodes = nodes.filter((n) => n.kind === "file");
+  const fileIds = fileNodes.map((n) => n.id).sort((a, b) => a.localeCompare(b));
+  if (fileIds.length === 0) {
+    return { areaByNode: new Map(nodes.map((n) => [n.id, -1])), mode: "none" };
+  }
+  const fileIdByPath = new Map(fileNodes.map((n) => [n.file, n.id]));
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file") fileOf.set(n.id, n.id);
+    else if (n.file) {
+      const fid = fileIdByPath.get(n.file);
+      if (fid) fileOf.set(n.id, fid);
+    }
+  }
+  const fileEdges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (!DEP_EDGES.has(e.kind)) continue;
+    const sf = fileOf.get(e.src);
+    const df = fileOf.get(e.dst);
+    if (!sf || !df || sf === df) continue;
+    const key = `${e.kind}|${sf}|${df}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    fileEdges.push({ ...e, src: sf, dst: df, id: key });
+  }
+  const { areaByNode: fileAreas, mode: used } = cluster(fileIds, fileEdges, mode);
+  const areaByNode = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const fid = fileOf.get(n.id);
+    areaByNode.set(n.id, fid ? fileAreas.get(fid) ?? -1 : -1);
+  }
+  return { areaByNode, mode: used };
 }
 function simpleGraph(ids, edges, kinds, type) {
   const g = new Graph({ type, multi: false, allowSelfLoops: false });
@@ -723,14 +770,14 @@ var DEFAULT_PATHS = [
 ];
 function loadCoverage(root, explicit) {
   const candidates = (explicit && explicit.length ? explicit : DEFAULT_PATHS).map(
-    (p) => path17.resolve(root, p)
+    (p) => path19.resolve(root, p)
   );
-  const found = candidates.filter((p) => fs15.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 = fs15.readFileSync(file, "utf8");
+      const text = fs18.readFileSync(file, "utf8");
       if (file.endsWith(".json")) mergeIstanbul(map, text, root);
       else mergeLcov(map, text, root);
     } catch {
@@ -739,8 +786,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 = 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);
@@ -1027,9 +1074,6 @@ function matchConfidence(entry, nameParts, imports, callees) {
   }
   return conf;
 }
-
-// src/schema.ts
-var SCHEMA_VERSION = "vg-graph/1.0";
 var DEFAULT_INLINE_THRESHOLD = 24;
 async function parseFiles(files, options = {}) {
   const threshold = options.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
@@ -1050,7 +1094,7 @@ async function parseInline(files, options) {
   onProgress?.(0, files.length);
   for (const file of files) {
     try {
-      const source = fs15.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}`));
@@ -1105,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 = path17.dirname(fileURLToPath(import.meta.url));
-  const candidate = path17.join(here, "parse-worker.js");
-  return fs15.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) }, () => []);
@@ -1356,7 +1400,7 @@ function enclosing3(nodes, line) {
   return best;
 }
 function normalize2(p) {
-  return path17.resolve(p).split(path17.sep).join("/");
+  return path19.resolve(p).split(path19.sep).join("/");
 }
 
 // src/engine/epistemic.ts
@@ -1599,14 +1643,14 @@ var IMPORTANCE = {
   "other-config": 0.08
 };
 function toPosix2(p) {
-  return p.split(path17.sep).join("/");
+  return p.split(path19.sep).join("/");
 }
 function buildRootIgnore2(root, exclude) {
   const ig = ignore();
-  const gitignorePath = path17.join(root, ".gitignore");
-  if (fs15.existsSync(gitignorePath)) {
+  const gitignorePath = path19.join(root, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) {
     try {
-      ig.add(fs15.readFileSync(gitignorePath, "utf8"));
+      ig.add(fs18.readFileSync(gitignorePath, "utf8"));
     } catch {
     }
   }
@@ -1615,7 +1659,7 @@ function buildRootIgnore2(root, exclude) {
 }
 function classifyProjectContext(relOrName) {
   const rel2 = relOrName.replace(/\\/g, "/");
-  const base = path17.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;
@@ -1628,7 +1672,7 @@ function classifyProjectContext(relOrName) {
   for (const { re, category } of PATH_PATTERNS) {
     if (re.test(rel2)) return category;
   }
-  const ext = path17.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)) {
@@ -1646,24 +1690,24 @@ function isEnvExampleName(baseLower) {
   return false;
 }
 function discoverDocs(options) {
-  const root = path17.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) => path17.resolve(root, p)) : [root]).filter(
-    (p) => fs15.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(path17.relative(root, abs));
+    const rel2 = toPosix2(path19.relative(root, abs));
     if (!rel2 || rel2.startsWith("..")) return;
     if (rootIg.ignores(rel2)) return;
-    const base = path17.basename(abs);
+    const base = path19.basename(abs);
     if (SKIP_FILES.has(base.toLowerCase())) return;
     const category = classifyProjectContext(rel2);
     if (!category) return;
     try {
-      const st = fs15.statSync(abs);
+      const st = fs18.statSync(abs);
       if (!st.isFile() || st.size > DOC_FILE_MAX_BYTES) return;
       if (st.size === 0) return;
     } catch {
@@ -1675,14 +1719,14 @@ function discoverDocs(options) {
     if (found.size >= maxFiles || depth > 12) return;
     let entries;
     try {
-      entries = fs15.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 = path17.join(dir, entry.name);
-      const rel2 = toPosix2(path17.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;
@@ -1694,7 +1738,7 @@ function discoverDocs(options) {
   };
   for (const scope of scopeAbs) {
     try {
-      const st = fs15.statSync(scope);
+      const st = fs18.statSync(scope);
       if (st.isDirectory()) walk(scope, 0);
       else if (st.isFile()) consider(scope);
     } catch {
@@ -1705,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" && path17.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)) {
@@ -1751,14 +1795,14 @@ function documentNodesFromDocs(docs) {
   for (const d of docs) {
     let raw = "";
     try {
-      raw = fs15.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 = path17.basename(d.rel);
+    const name = path19.basename(d.rel);
     const qualifiedName = d.rel.replace(/\\/g, "/");
     const id = nodeId({
       kind: "document",
@@ -1787,17 +1831,362 @@ function documentNodesFromDocs(docs) {
   }
   return nodes.sort((a, b) => a.file.localeCompare(b.file) || a.id.localeCompare(b.id));
 }
+function shardTsProjects(root, files) {
+  if (files.length === 0) return [];
+  const cache = /* @__PURE__ */ new Map();
+  const byKey = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = path19.dirname(f.abs);
+    const key = nearestProjectKey(root, dir, cache);
+    const list = byKey.get(key);
+    if (list) list.push(f);
+    else byKey.set(key, [f]);
+  }
+  return [...byKey.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([key, shardFiles]) => ({
+    key,
+    files: [...shardFiles].sort((a, b) => a.rel.localeCompare(b.rel))
+  }));
+}
+function nearestProjectKey(root, startDir, cache) {
+  const hit = cache.get(startDir);
+  if (hit !== void 0) return hit;
+  let dir = startDir;
+  const rootAbs = path19.resolve(root);
+  while (true) {
+    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 || path19.dirname(dir) === dir) {
+      cache.set(startDir, ".");
+      return ".";
+    }
+    dir = path19.dirname(dir);
+  }
+}
+function toPosix3(p) {
+  return p.split(path19.sep).join("/");
+}
+
+// src/engine/timing.ts
+var StageTimer = class {
+  marks = /* @__PURE__ */ new Map();
+  durations = {};
+  start(name) {
+    this.marks.set(name, nowMs());
+  }
+  end(name) {
+    const t0 = this.marks.get(name);
+    if (t0 === void 0) return 0;
+    const ms = Math.round((nowMs() - t0) * 1e3) / 1e3;
+    this.durations[name] = ms;
+    this.marks.delete(name);
+    return ms;
+  }
+  /** Run `fn` under a named stage. */
+  async measure(name, fn) {
+    this.start(name);
+    try {
+      return await fn();
+    } finally {
+      this.end(name);
+    }
+  }
+  snapshot() {
+    return { ...this.durations };
+  }
+};
+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 start = nowMs();
-  const root = path17.resolve(options.root);
+  const timer = new StageTimer();
+  timer.start("total");
+  const root = path19.resolve(options.root);
+  timer.start("discover");
   const files = discover({
     root,
     only: options.only,
     exclude: options.exclude,
     paths: options.paths
   });
+  timer.end("discover");
   const limits = resolveLimits(options.limits);
   if (limits.maxFiles > 0 && files.length > limits.maxFiles) {
     throw new ResourceLimitError(
@@ -1811,15 +2200,18 @@ async function buildGraph(options) {
     grammars,
     disabled: options.noCache
   });
+  timer.start("hash");
   const hashes = /* @__PURE__ */ new Map();
   const fileStats = [];
   const toParse = [];
   const reused = [];
   const buildWarnings = [];
+  let statHits = 0;
+  const pendingHash = [];
   for (const file of files) {
     let stat;
     try {
-      stat = fs15.statSync(file.abs);
+      stat = fs18.statSync(file.abs);
     } catch {
       continue;
     }
@@ -1835,18 +2227,47 @@ async function buildGraph(options) {
       );
       continue;
     }
-    let hash = "";
-    try {
-      hash = hashBytes(fs15.readFileSync(file.abs));
-    } catch {
+    const byStat = options.noCache ? void 0 : cache.getByStat(file.rel, stat.mtimeMs, stat.size);
+    if (byStat) {
+      hashes.set(file.rel, byStat.hash);
+      if (byStat.parse.hash !== byStat.hash) byStat.parse.hash = byStat.hash;
+      fileStats.push({
+        rel: file.rel,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        hash: byStat.hash
+      });
+      reused.push(byStat.parse);
+      statHits++;
       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);
-    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");
+  timer.start("parse");
   const parsedNew = await parseFiles(toParse, {
     jobs: options.jobs,
     inline: options.inline,
@@ -1854,8 +2275,12 @@ async function buildGraph(options) {
     grammarsDir: options.grammarsDir,
     memoryBudgetMb: limits.memoryBudgetMb
   });
+  timer.end("parse");
   checkMemoryBudget("parse", limits.memoryBudgetMb);
-  for (const p of parsedNew) cache.set(p.rel, p);
+  for (const p of parsedNew) {
+    const st = fileStats.find((f) => f.rel === p.rel);
+    cache.set(p.rel, p, st ? { mtimeMs: st.mtimeMs, size: st.size } : void 0);
+  }
   const currentRels = new Set(files.map((f) => f.rel));
   cache.prune(currentRels);
   cache.save();
@@ -1863,31 +2288,85 @@ async function buildGraph(options) {
     (a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0
   );
   const warnings = [...buildWarnings, ...parses.flatMap((p) => p.warnings ?? [])];
+  timer.start("resolve");
   const moduleResolver = buildModuleResolver(root, new Set(parses.map((p) => p.rel)));
   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];
   const preciseCoveredFiles = /* @__PURE__ */ new Set();
   let tscStats;
-  let tsFiles = options.noTsc ? [] : files.filter((f) => (f.lang.id === "ts" || f.lang.id === "tsx" || f.lang.id === "js") && hashes.has(f.rel)).map((f) => ({ rel: f.rel, abs: f.abs }));
+  const skipTsc = options.noTsc || options.fast;
+  let tsFiles = skipTsc ? [] : files.filter((f) => (f.lang.id === "ts" || f.lang.id === "tsx" || f.lang.id === "js") && hashes.has(f.rel)).map((f) => ({ rel: f.rel, abs: f.abs }));
   if (limits.tscMaxFiles > 0 && tsFiles.length > limits.tscMaxFiles) {
     warnings.push(
       `typescript resolver skipped \u2014 ${tsFiles.length.toLocaleString()} TS/JS files exceed the ${limits.tscMaxFiles.toLocaleString()}-file limit; calls use the heuristic resolver (set VG_TSC_MAX_FILES to raise it, 0 to disable)`
     );
     tsFiles = [];
   }
+  timer.start("tsc");
   if (tsFiles.length) {
-    const res = tsResolveEdges(root, tsFiles, resolved.nodes);
-    if (res.stats.files > 0) {
-      edges = mergePreciseEdges(edges, res.edges, res.coveredFiles, nodeFileById);
-      for (const f of res.coveredFiles) preciseCoveredFiles.add(f);
+    const shards = shardTsProjects(root, tsFiles);
+    let filesCovered = 0;
+    let calls = 0;
+    let jsx = 0;
+    let heritage = 0;
+    let resolvedCount = 0;
+    const coveredAll = /* @__PURE__ */ new Set();
+    const preciseAll = [];
+    for (const shard of shards) {
+      const res = tsResolveEdges(root, shard.files, resolved.nodes);
+      if (res.stats.files === 0) continue;
+      filesCovered += res.stats.files;
+      calls += res.stats.calls;
+      jsx += res.stats.jsx;
+      heritage += res.stats.heritage;
+      resolvedCount += res.stats.resolved;
+      for (const f of res.coveredFiles) coveredAll.add(f);
+      preciseAll.push(...res.edges);
+    }
+    if (filesCovered > 0) {
+      edges = mergePreciseEdges(edges, preciseAll, coveredAll, nodeFileById);
+      for (const f of coveredAll) preciseCoveredFiles.add(f);
       if (!resolvers.includes("tsc")) resolvers.unshift("tsc");
-      tscStats = res.stats;
+      tscStats = {
+        files: filesCovered,
+        calls,
+        jsx,
+        heritage,
+        resolved: resolvedCount,
+        shards: shards.length
+      };
     }
     checkMemoryBudget("typescript resolution", limits.memoryBudgetMb);
   }
+  timer.end("tsc");
   const scip = options.noScip ? null : loadScipIndex(root, options.scip);
   let scipStats;
   if (scip) {
@@ -1908,8 +2387,8 @@ async function buildGraph(options) {
   });
   for (const d of docs) {
     try {
-      const st = fs15.statSync(d.abs);
-      const hash = hashBytes(fs15.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 {
@@ -1917,7 +2396,12 @@ async function buildGraph(options) {
   }
   const docNodes = documentNodesFromDocs(docs);
   if (docNodes.length) nodes = [...nodes, ...docNodes];
-  const analysis = analyze(nodes, linked.edges, { cluster: options.cluster });
+  timer.start("analyze");
+  const analysis = analyze(nodes, linked.edges, {
+    cluster: options.cluster,
+    tier: options.analysisTier
+  });
+  timer.end("analyze");
   checkMemoryBudget("analysis", limits.memoryBudgetMb);
   const languages = [.../* @__PURE__ */ new Set([...parses.map((p) => p.lang), ...docNodes.map((n) => n.lang)])].sort();
   const edgeKinds = [...new Set(analysis.edges.map((e) => e.kind))].sort();
@@ -1945,8 +2429,9 @@ async function buildGraph(options) {
       toolchain
     },
     meta: {
-      root: path17.basename(root) === "" ? "." : ".",
+      root: path19.basename(root) === "" ? "." : ".",
       languages,
+      analysisTier: analysis.tier,
       counts: {
         nodes: analysis.nodes.length,
         edges: analysis.edges.length,
@@ -1964,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;
   }
@@ -1972,16 +2458,27 @@ async function buildGraph(options) {
     const grounding = groundGraph(analysis.nodes, analysis.edges, parses);
     if (grounding.length) graph.grounding = grounding;
   }
+  let indexResult;
+  if (!options.noIndex) {
+    timer.start("index");
+    const wr = writeGraphIndex(root, graph);
+    indexResult = { ok: wr.ok, path: wr.ok ? wr.path : void 0, reason: wr.reason };
+    timer.end("index");
+  }
+  timer.end("total");
+  const stages = timer.snapshot();
   return {
     graph,
-    timing: { totalMs: Math.round((nowMs() - start) * 1e3) / 1e3 },
+    timing: { totalMs: stages.total ?? 0, stages },
     reparsed: parsedNew.length,
     reused: reused.length,
+    statHits,
     totalFiles: files.length,
     fileStats,
     resolveStats: resolved.stats,
     tsc: tscStats,
     scip: scipStats,
+    index: indexResult,
     warnings
   };
 }
@@ -1991,14 +2488,14 @@ function toRepoRel(p) {
 function loadScipIndex(root, explicit) {
   const candidates = [
     explicit,
-    path17.join(root, "index.scip"),
-    path17.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 = path17.isAbsolute(file) ? file : path17.resolve(root, file);
-    if (!fs15.existsSync(abs)) continue;
+    const abs = path19.isAbsolute(file) ? file : path19.resolve(root, file);
+    if (!fs18.existsSync(abs)) continue;
     try {
-      const index = decodeScipIndex(new Uint8Array(fs15.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 };
       }
@@ -2047,9 +2544,6 @@ function computeCorpusHash(parses, hashes) {
   const list = [...byRel.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
   return hashString(canonicalize(list));
 }
-function nowMs() {
-  return Number(process.hrtime.bigint() / 1000n) / 1e3;
-}
 
 // src/engine/verify.ts
 var PINNED = "1970-01-01T00:00:00.000Z";
@@ -2116,21 +2610,21 @@ function usageError(message) {
 }
 var SNAPSHOT_VERSION = "vg-freshness/1";
 function snapshotPath(root) {
-  return path17.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 {
-    fs15.mkdirSync(cacheDir(root), { recursive: true });
-    fs15.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(fs15.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 ?? {} };
     }
@@ -2150,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;
   }
@@ -2166,15 +2667,25 @@ function probeFreshness(root) {
     }
     let stat;
     try {
-      stat = fs15.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(fs15.readFileSync(file.abs));
+      hash = hashBytes(fs18.readFileSync(file.abs));
     } catch {
       drift.removed.push(file.rel);
       continue;
@@ -2191,7 +2702,7 @@ function probeFreshness(root) {
   }
   if (absorbed && !hasDrift(drift)) {
     try {
-      fs15.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+      fs18.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
     } catch {
     }
   }
@@ -2237,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;
@@ -2272,10 +2807,10 @@ function testsToRun(graph, rootId, depth = 4) {
   };
 }
 function detectRunner(root, lang) {
-  const pkgPath = path17.join(root, "package.json");
-  if (fs15.existsSync(pkgPath)) {
+  const pkgPath = path19.join(root, "package.json");
+  if (fs18.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs15.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() };
@@ -2283,10 +2818,10 @@ function detectRunner(root, lang) {
     } catch {
     }
   }
-  if (lang === "py" || fs15.existsSync(path17.join(root, "pyproject.toml")) || fs15.existsSync(path17.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" || fs15.existsSync(path17.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$/)) {
@@ -2297,16 +2832,16 @@ function detectRunner(root, lang) {
 }
 function hasFile(root, re) {
   try {
-    return fs15.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 = path17.resolve(startDir);
+  let dir = path19.resolve(startDir);
   for (; ; ) {
-    if (fs15.existsSync(path17.join(dir, ".git"))) return dir;
-    const parent = path17.dirname(dir);
+    if (fs18.existsSync(path19.join(dir, ".git"))) return dir;
+    const parent = path19.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -2317,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 = path17.join(root, ".gitignore");
+  const gitignorePath = path19.join(root, ".gitignore");
   const target = normalizeEntry(entry);
   let existing = "";
   let fileExisted = true;
   try {
-    existing = fs15.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");
-  fs15.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
+  fs18.appendFileSync(gitignorePath, `${needsLeadingNewline ? "\n" : ""}${entry}
 `, "utf8");
   return { status: fileExisted ? "added" : "created", entry, gitignorePath };
 }
@@ -2483,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 = path17.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(path17.dirname(writePath));
-    const rel2 = root ? path17.relative(root, writePath).split(path17.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, path17.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") {
@@ -2508,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 path17.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 path17.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 path17.resolve(override);
+  if (override) return path19.resolve(override);
   const local = projectCredentialsPath(opts.cwd);
   if (opts.local) return local;
-  if (fs15.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 = 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 = fs15.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 {
@@ -2540,16 +3075,16 @@ function readStoredCredentials(opts = {}) {
 }
 function writeStoredCredentials(creds, opts = {}) {
   const file = credentialsPath(opts);
-  fs15.mkdirSync(path17.dirname(file), { recursive: true });
-  fs15.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 {
-    fs15.chmodSync(file, 384);
+    fs18.chmodSync(file, 384);
   } catch {
   }
 }
 function clearStoredCredentials(opts = {}) {
   try {
-    fs15.rmSync(credentialsPath(opts));
+    fs18.rmSync(credentialsPath(opts));
     return true;
   } catch {
     return false;
@@ -2920,7 +3455,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 = 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.'));
@@ -3015,7 +3550,7 @@ function measure(root, files) {
   for (const rel2 of files) {
     let size;
     try {
-      size = fs15.statSync(path17.join(root, rel2)).size;
+      size = fs18.statSync(path19.join(root, rel2)).size;
     } catch {
       continue;
     }
@@ -3038,9 +3573,9 @@ function matchLines(text, needleLower) {
 }
 function readCandidate(abs, knownSize) {
   try {
-    const size = knownSize ?? fs15.statSync(abs).size;
+    const size = knownSize ?? fs18.statSync(abs).size;
     if (size > MAX_FILE_BYTES) return null;
-    const text = fs15.readFileSync(abs, "utf8");
+    const text = fs18.readFileSync(abs, "utf8");
     return text.includes(NUL) ? null : text;
   } catch {
     return null;
@@ -3051,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(path17.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++;
@@ -3118,12 +3653,12 @@ var WORKER_SOURCE = [
   "parentPort.postMessage({ hits, total, truncated });"
 ].join("\n");
 function runWorker(root, files, needleLower) {
-  return new Promise((resolve11, 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;
-      resolve11(m);
+      resolve13(m);
     });
     w.once("error", reject);
     w.once("exit", (code) => {
@@ -3192,10 +3727,10 @@ var BINARY_EXTS = /* @__PURE__ */ new Set([
   ".pdf"
 ]);
 function hasBinaryExt(rel2) {
-  return BINARY_EXTS.has(path17.extname(rel2).toLowerCase());
+  return BINARY_EXTS.has(path19.extname(rel2).toLowerCase());
 }
-function toPosix3(rel2) {
-  return path17.sep === "\\" ? rel2.replaceAll("\\", "/") : rel2;
+function toPosix4(rel2) {
+  return path19.sep === "\\" ? rel2.replaceAll("\\", "/") : rel2;
 }
 async function searchSymbols(graph, root, query, limit) {
   let q = query.trim();
@@ -3334,13 +3869,13 @@ function walkCandidates(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs15.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 = path19.join(dir, e.name);
       if (e.isDirectory()) {
         stack.push(abs);
         continue;
@@ -3350,7 +3885,7 @@ function walkCandidates(root) {
         truncated = true;
         continue;
       }
-      files.push(toPosix3(path17.relative(root, abs)));
+      files.push(toPosix4(path19.relative(root, abs)));
     }
   }
   files.sort();
@@ -3381,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, sep8 = path17.sep) {
+function parseRgFileList(stdout, sep10 = path19.sep) {
   const seen = /* @__PURE__ */ new Set();
   for (const raw of stdout.split("\n")) {
     if (!raw) continue;
-    const posix = sep8 === "\\" ? 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;
@@ -3397,8 +3932,8 @@ function parseRgFileList(stdout, sep8 = path17.sep) {
 }
 function readScanArtifact(root) {
   try {
-    const file = path17.join(root, ".vibgrate", "scan_result.json");
-    return JSON.parse(fs15.readFileSync(file, "utf8"));
+    const file = path19.join(root, ".vibgrate", "scan_result.json");
+    return JSON.parse(fs18.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -3788,7 +4323,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 path17.join(cacheDir(root), "hosted-docs.json");
+  return path19.join(cacheDir(root), "hosted-docs.json");
 }
 function hostedDocsCacheKey(req, opts = {}) {
   const material = JSON.stringify([
@@ -3804,7 +4339,7 @@ function hostedDocsCacheKey(req, opts = {}) {
 }
 function loadFile(root) {
   try {
-    const parsed = JSON.parse(fs15.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 {
   }
@@ -3818,8 +4353,8 @@ function saveFile(root, file) {
         delete file.entries[k];
       }
     }
-    fs15.mkdirSync(cacheDir(root), { recursive: true });
-    fs15.writeFileSync(cachePath(root), JSON.stringify(file));
+    fs18.mkdirSync(cacheDir(root), { recursive: true });
+    fs18.writeFileSync(cachePath(root), JSON.stringify(file));
   } catch {
   }
 }
@@ -4107,11 +4642,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,
@@ -4140,7 +4675,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) };
     }
@@ -4233,18 +4768,47 @@ 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.",
+    description: "Deterministic facts for a node (contract / invariant / characterization).",
     inputSchema: obj({ name: { type: "string" } }, ["name"]),
     handler: (graph, args) => {
       const { node, candidates } = resolveOne(graph, String(args.name ?? ""));
       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)) };
     }
   },
@@ -4536,14 +5100,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) {
@@ -4571,7 +5143,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"];
@@ -4794,12 +5366,12 @@ function detectAssistants(root, opts = {}) {
   const which = opts.which ?? whichOnPath;
   const found = [];
   for (const assistant of ASSISTANTS) {
-    const repoHit = (assistant.markers ?? []).find((m) => fs15.existsSync(path17.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) => fs15.existsSync(path17.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;
@@ -4831,19 +5403,19 @@ function installAssistant(a, opts) {
   const skipped = [];
   let note;
   if (a.skill) {
-    writeFileEnsured(path17.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(path17.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(path17.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)");
@@ -4853,41 +5425,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 = path19.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 = path19.join(root, a.nudge.file);
     if (a.nudge.kind === "block") {
       if (removeBlock(file)) removed.push(a.nudge.file);
-    } else if (fs15.existsSync(file)) {
-      fs15.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 (fs15.existsSync(file)) {
-      fs15.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) {
-  fs15.mkdirSync(path17.dirname(file), { recursive: true });
-  fs15.writeFileSync(file, content);
+  fs18.mkdirSync(path19.dirname(file), { recursive: true });
+  fs18.writeFileSync(file, content);
 }
 function writeNavigationConfig(root) {
   ensureVibgrateGitignore(root);
-  const rel2 = path17.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(path17.join(root, rel2), `${JSON.stringify(doc, null, 2)}
+  writeFileEnsured(path19.join(root, rel2), `${JSON.stringify(doc, null, 2)}
 `);
   return rel2;
 }
@@ -4902,7 +5474,7 @@ function upsertMcp(file, target, launch) {
 `);
 }
 function removeMcp(file, target) {
-  if (!fs15.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;
@@ -4921,8 +5493,8 @@ function refreshInstalledInstructions(root, smallRepo) {
   };
   for (const a of ASSISTANTS) {
     if (a.skill) {
-      const file = path17.join(root, a.skill);
-      if (fs15.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) {
@@ -4932,8 +5504,8 @@ function refreshInstalledInstructions(root, smallRepo) {
       }
     }
     if (a.nudge) {
-      const file = path17.join(root, a.nudge.file);
-      if (!fs15.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") {
@@ -4957,7 +5529,7 @@ function refreshInstalledInstructions(root, smallRepo) {
 }
 function readTextSafe(file) {
   try {
-    return fs15.readFileSync(file, "utf8");
+    return fs18.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -4976,8 +5548,8 @@ ${stripMarkers(nudgeMarkdown(smallRepo, client))}` : stripMarkers(nudgeMarkdown(
   upsertBlock(file, nudgeMarkdown(smallRepo, client));
 }
 function upsertBlock(file, block) {
-  fs15.mkdirSync(path17.dirname(file), { recursive: true });
-  let existing = fs15.existsSync(file) ? fs15.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*$/, "")}
@@ -4985,20 +5557,20 @@ function upsertBlock(file, block) {
 ${block}
 ` : `${block}
 `;
-  fs15.writeFileSync(file, existing);
+  fs18.writeFileSync(file, existing);
 }
 function removeBlock(file) {
-  if (!fs15.existsSync(file)) return false;
-  const existing = fs15.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;
-  fs15.writeFileSync(file, existing.replace(re, "\n"));
+  fs18.writeFileSync(file, existing.replace(re, "\n"));
   return true;
 }
 function readJson(file) {
-  if (!fs15.existsSync(file)) return {};
+  if (!fs18.existsSync(file)) return {};
   try {
-    const parsed = JSON.parse(fs15.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -5018,7 +5590,7 @@ function escapeRe(s) {
 }
 var REFRESH_LOCK_STALE_MS = 10 * 60 * 1e3;
 function refreshLockPath(root) {
-  return path17.join(cacheDir(root), "refresh.lock");
+  return path19.join(cacheDir(root), "refresh.lock");
 }
 async function refreshIfStale(root, opts = {}) {
   const probe = probeFreshness(root);
@@ -5050,8 +5622,8 @@ async function refreshIfStale(root, opts = {}) {
       writeArtifacts(result.graph, {
         root,
         graphPath: opts.graphPath,
-        report: fs15.existsSync(path17.join(dir, "GRAPH_REPORT.md")),
-        html: fs15.existsSync(path17.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);
@@ -5071,6 +5643,6 @@ async function refreshIfStale(root, opts = {}) {
   }
 }
 
-export { ASSISTANTS, CliError, ExitCode, FREE_PACK, NPX_INVOCATION, ResourceLimitError, SCHEMA_VERSION, 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-S6CYDZEW.js.map
-//# sourceMappingURL=chunk-S6CYDZEW.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-MAY5HLDH.js.map
+//# sourceMappingURL=chunk-MAY5HLDH.js.map