@vibgrate/cli 2026.728.3 → 2026.728.4

package/dist/chunk-WDJNUC6V.js

@@ -0,0 +1,3059 @@
+import { FREE_PACK, navigationToolsetConfig, deferredToolNames, HOT_TOOLS } from './chunk-SA4BMEU6.js';
+import { edgeId, buildModuleResolver, resolve, applyStaticTestLinkage, nodeId } from './chunk-IPICO2RV.js';
+import { VERSION } from './chunk-RCBMY7CR.js';
+import { acquireLock, releaseLock, indexFor } from './chunk-EETK7S43.js';
+import { init_cli_invocation, whichOnPath, isInstalledOwnBinary } from './chunk-3LSG7Z4I.js';
+import { langById, grammarSetVersion, langForExtension, setGrammarsOverride, parseSource } from './chunk-UTNNGKKX.js';
+import { redactSecrets } from './chunk-RXP66R2E.js';
+import { writeGraphIndex, SCHEMA_VERSION, loadGraph, ensureVibgrateGitignore, vibgrateDir, writeArtifacts } from './chunk-RYNAK4LK.js';
+import { loadCache, serializeGraph, cacheDir, stableStringify } from './chunk-ZKNB4YH4.js';
+import { shortId, canonicalize, hashString, hashBytes } from './chunk-JFGYT6BI.js';
+import * as fs10 from 'fs';
+import * as path10 from 'path';
+import ignore from 'ignore';
+import * as v8 from 'v8';
+import Graph from 'graphology';
+import pagerank from 'graphology-metrics/centrality/pagerank.js';
+import betweenness from 'graphology-metrics/centrality/betweenness.js';
+import eigenvector from 'graphology-metrics/centrality/eigenvector.js';
+import louvain from 'graphology-communities-louvain';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+import ts from 'typescript';
+import * as fs7 from 'fs/promises';
+
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  // Version control, IDE & tool metadata
+  ".git",
+  ".svn",
+  ".hg",
+  ".idea",
+  ".vscode",
+  ".vs",
+  ".vibgrate",
+  ".wrangler",
+  ".turbo",
+  ".cache",
+  // Migration / tool backup trees (NativeScript, codemods, agent worktrees)
+  ".migration_backup",
+  ".update_backup",
+  ".backup",
+  ".bak",
+  ".history",
+  ".snapshots",
+  ".snapshots_bak",
+  // JavaScript / Node — installed dependency trees
+  "node_modules",
+  "bower_components",
+  "jspm_packages",
+  "web_modules",
+  ".pnpm-store",
+  ".yarn",
+  // JS/TS meta-framework & bundler build output
+  ".next",
+  ".nuxt",
+  ".output",
+  ".svelte-kit",
+  ".astro",
+  ".vercel",
+  ".netlify",
+  ".angular",
+  ".parcel-cache",
+  ".docusaurus",
+  "storybook-static",
+  // Generic build / dist / coverage output
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  // Native mobile platform build trees (NativeScript / Cordova / Capacitor)
+  "platforms",
+  "App_Resources",
+  // Vendored third-party source trees
+  "vendor",
+  "Pods",
+  "Carthage",
+  // Python — virtualenvs & tool caches
+  ".venv",
+  "venv",
+  "virtualenv",
+  ".tox",
+  ".nox",
+  "__pycache__",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".eggs",
+  ".ipynb_checkpoints",
+  // Ruby
+  ".bundle",
+  // Rust / Maven / sbt / Clojure — all build into target/
+  "target",
+  // JVM (Gradle / Maven) & .NET build output
+  ".gradle",
+  "bin",
+  "obj",
+  "TestResults",
+  // Swift / Xcode
+  ".build",
+  ".swiftpm",
+  "DerivedData",
+  // Dart / Flutter
+  ".dart_tool",
+  // Elixir / Erlang
+  "_build",
+  "deps",
+  // Haskell (Cabal / Stack)
+  "dist-newstyle",
+  ".stack-work",
+  // Infrastructure-as-code build/state
+  ".terraform",
+  ".serverless",
+  "cdk.out",
+  ".aws-sam"
+]);
+var SKIP_FILES = /* @__PURE__ */ new Set([
+  // JavaScript / Node
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "bun.lock",
+  "deno.lock",
+  ".pnp.cjs",
+  ".pnp.data.json",
+  ".pnp.loader.mjs",
+  // Python
+  "poetry.lock",
+  "pipfile.lock",
+  "pdm.lock",
+  "uv.lock",
+  "pylock.toml",
+  "conda-lock.yml",
+  // Ruby
+  "gemfile.lock",
+  // PHP
+  "composer.lock",
+  // Rust
+  "cargo.lock",
+  // Go
+  "go.sum",
+  "go.work.sum",
+  "gopkg.lock",
+  "glide.lock",
+  // .NET
+  "packages.lock.json",
+  // Java / JVM (Gradle)
+  "gradle.lockfile",
+  // Swift / Xcode
+  "package.resolved",
+  // Dart / Flutter
+  "pubspec.lock",
+  // Elixir
+  "mix.lock",
+  // Haskell (Cabal / Stack)
+  "cabal.project.freeze",
+  "stack.yaml.lock",
+  // Julia
+  "manifest.toml",
+  // R
+  "renv.lock",
+  // Perl (Carton)
+  "cpanfile.snapshot",
+  // CocoaPods / Carthage
+  "podfile.lock",
+  "cartfile.resolved",
+  // Terraform / IaC
+  ".terraform.lock.hcl",
+  // Helm
+  "chart.lock",
+  // C / C++ (Conan)
+  "conan.lock",
+  // Bazel
+  "module.bazel.lock",
+  // Nix
+  "flake.lock"
+]);
+function toPosix(p) {
+  return p.split(path10.sep).join("/");
+}
+function buildRootIgnore(root, exclude) {
+  const ig = ignore();
+  const gitignorePath = path10.join(root, ".gitignore");
+  if (fs10.existsSync(gitignorePath)) {
+    ig.add(fs10.readFileSync(gitignorePath, "utf8"));
+  }
+  if (exclude.length) ig.add(exclude);
+  return ig;
+}
+function discover(options) {
+  const root = path10.resolve(options.root);
+  const onlyLangs = (options.only ?? []).filter(Boolean);
+  const allowLang = (lang) => onlyLangs.length === 0 || onlyLangs.includes(lang.id);
+  for (const id of onlyLangs) {
+    if (!langById(id)) {
+      throw new UsageError(`unknown language "${id}" for --only`);
+    }
+  }
+  const rootIg = buildRootIgnore(root, options.exclude ?? []);
+  const scopeAbs = (options.paths && options.paths.length ? options.paths.map((p) => path10.resolve(root, p)) : [root]).filter((p) => fs10.existsSync(p));
+  const found = /* @__PURE__ */ new Map();
+  const considerFile = (abs) => {
+    const rel2 = toPosix(path10.relative(root, abs));
+    if (rel2.startsWith("..")) return;
+    if (rel2 === "" || rootIg.ignores(rel2)) return;
+    if (SKIP_FILES.has(path10.basename(abs).toLowerCase())) return;
+    const lang = langForExtension(path10.extname(abs));
+    if (!lang || !allowLang(lang)) return;
+    found.set(rel2, { rel: rel2, abs, lang });
+  };
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path10.join(dir, entry.name);
+      const rel2 = toPosix(path10.relative(root, abs));
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (rel2 && rootIg.ignores(`${rel2}/`)) continue;
+        walk(abs);
+      } else if (entry.isFile()) {
+        considerFile(abs);
+      }
+    }
+  };
+  for (const scope of scopeAbs) {
+    const stat = fs10.statSync(scope);
+    if (stat.isDirectory()) walk(scope);
+    else if (stat.isFile()) considerFile(scope);
+  }
+  return [...found.values()].sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+}
+var UsageError = class extends Error {
+  isUsageError = true;
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
+var MIB = 1024 * 1024;
+var DEFAULT_MAX_FILE_BYTES = 2 * MIB;
+var DEFAULT_MAX_FILES = 1e5;
+var DEFAULT_TSC_MAX_FILES = 1e4;
+var HEAP_GUARD_FRACTION = 0.9;
+var ResourceLimitError = class extends Error {
+  isResourceLimitError = true;
+  constructor(message) {
+    super(message);
+    this.name = "ResourceLimitError";
+  }
+};
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 0 ? n : fallback;
+}
+function envIntOptional(name) {
+  const n = envInt(name, 0);
+  return n > 0 ? n : void 0;
+}
+function defaultMemoryBudgetMb() {
+  return Math.floor(v8.getHeapStatistics().heap_size_limit / MIB * HEAP_GUARD_FRACTION);
+}
+function resolveLimits(overrides = {}) {
+  return {
+    maxFileBytes: overrides.maxFileBytes ?? envInt("VG_MAX_FILE_BYTES", DEFAULT_MAX_FILE_BYTES),
+    maxFiles: overrides.maxFiles ?? envInt("VG_MAX_FILES", DEFAULT_MAX_FILES),
+    tscMaxFiles: overrides.tscMaxFiles ?? envInt("VG_TSC_MAX_FILES", DEFAULT_TSC_MAX_FILES),
+    memoryBudgetMb: overrides.memoryBudgetMb ?? envInt("VG_MEMORY_BUDGET_MB", defaultMemoryBudgetMb())
+  };
+}
+function envJobs() {
+  return envIntOptional("VG_JOBS");
+}
+function envWorkerHeapMb() {
+  return envIntOptional("VG_WORKER_HEAP_MB");
+}
+function checkMemoryBudget(phase, budgetMb) {
+  if (budgetMb <= 0) return;
+  const usedMb = process.memoryUsage().heapUsed / MIB;
+  if (usedMb <= budgetMb) return;
+  throw new ResourceLimitError(
+    `graph build stopped during ${phase}: heap use ${Math.round(usedMb)} MiB exceeds the ${budgetMb} MiB budget. Narrow the build (scope to sub-paths, add --exclude globs, or --only <langs>), raise the Node heap (NODE_OPTIONS=--max-old-space-size=8192), or set VG_MEMORY_BUDGET_MB (0 disables this safeguard).`
+  );
+}
+function formatBytes(n) {
+  if (n >= MIB) return `${(n / MIB).toFixed(1)} MiB`;
+  if (n >= 1024) return `${(n / 1024).toFixed(1)} KiB`;
+  return `${n} B`;
+}
+
+// src/engine/scip.ts
+var ROLE_DEFINITION = 1;
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  pos = 0;
+  get done() {
+    return this.pos >= this.buf.length;
+  }
+  varint() {
+    let result = 0;
+    let shift = 0;
+    for (; ; ) {
+      const b = this.buf[this.pos++];
+      result += (b & 127) * 2 ** shift;
+      if ((b & 128) === 0) break;
+      shift += 7;
+    }
+    return result;
+  }
+  tag() {
+    const t = this.varint();
+    return { field: t >>> 3, wire: t & 7 };
+  }
+  bytes() {
+    const len = this.varint();
+    const out = this.buf.subarray(this.pos, this.pos + len);
+    this.pos += len;
+    return out;
+  }
+  skip(wire) {
+    if (wire === 0) this.varint();
+    else if (wire === 2) this.bytes();
+    else if (wire === 5) this.pos += 4;
+    else if (wire === 1) this.pos += 8;
+  }
+};
+var td = new TextDecoder();
+function decodeScipIndex(buf) {
+  const index = { documents: [] };
+  const r = new Reader(buf);
+  while (!r.done) {
+    const { field, wire } = r.tag();
+    if (field === 1 && wire === 2) decodeMetadata(r.bytes(), index);
+    else if (field === 2 && wire === 2) index.documents.push(decodeDocument(r.bytes()));
+    else r.skip(wire);
+  }
+  return index;
+}
+function decodeMetadata(buf, index) {
+  const r = new Reader(buf);
+  while (!r.done) {
+    const { field, wire } = r.tag();
+    if (field === 2 && wire === 2) decodeToolInfo(r.bytes(), index);
+    else r.skip(wire);
+  }
+}
+function decodeToolInfo(buf, index) {
+  const r = new Reader(buf);
+  while (!r.done) {
+    const { field, wire } = r.tag();
+    if (field === 1 && wire === 2) index.toolName = td.decode(r.bytes());
+    else if (field === 2 && wire === 2) index.toolVersion = td.decode(r.bytes());
+    else r.skip(wire);
+  }
+}
+function decodeDocument(buf) {
+  const doc = { relativePath: "", occurrences: [] };
+  const r = new Reader(buf);
+  while (!r.done) {
+    const { field, wire } = r.tag();
+    if (field === 1 && wire === 2) doc.relativePath = td.decode(r.bytes());
+    else if (field === 2 && wire === 2) doc.occurrences.push(decodeOccurrence(r.bytes()));
+    else r.skip(wire);
+  }
+  return doc;
+}
+function decodeOccurrence(buf) {
+  const occ = { range: [], symbol: "", roles: 0 };
+  const r = new Reader(buf);
+  while (!r.done) {
+    const { field, wire } = r.tag();
+    if (field === 1) {
+      if (wire === 2) {
+        const sub = new Reader(r.bytes());
+        while (!sub.done) occ.range.push(sub.varint());
+      } else if (wire === 0) {
+        occ.range.push(r.varint());
+      } else r.skip(wire);
+    } else if (field === 2 && wire === 2) occ.symbol = td.decode(r.bytes());
+    else if (field === 3 && wire === 0) occ.roles = r.varint();
+    else r.skip(wire);
+  }
+  return occ;
+}
+function scipEdges(index, nodes, relForScip) {
+  const nodesByFile = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    const list = nodesByFile.get(n.file);
+    if (list) list.push(n);
+    else nodesByFile.set(n.file, [n]);
+  }
+  const symbolToNode = /* @__PURE__ */ new Map();
+  const coveredFiles = /* @__PURE__ */ new Set();
+  for (const doc of index.documents) {
+    const file = relForScip(doc.relativePath);
+    const fileNodes = nodesByFile.get(file);
+    if (!fileNodes) continue;
+    coveredFiles.add(file);
+    for (const occ of doc.occurrences) {
+      if ((occ.roles & ROLE_DEFINITION) === 0 || !occ.symbol || occ.symbol.startsWith("local ")) continue;
+      const line = (occ.range[0] ?? 0) + 1;
+      const node = nodeStartingAt(fileNodes, line) ?? enclosing(fileNodes, line);
+      if (node) symbolToNode.set(occ.symbol, node);
+    }
+  }
+  const edgeMap = /* @__PURE__ */ new Map();
+  let references = 0;
+  let resolved = 0;
+  for (const doc of index.documents) {
+    const file = relForScip(doc.relativePath);
+    const fileNodes = nodesByFile.get(file);
+    if (!fileNodes) continue;
+    for (const occ of doc.occurrences) {
+      if ((occ.roles & ROLE_DEFINITION) !== 0 || !occ.symbol || occ.symbol.startsWith("local ")) continue;
+      references++;
+      const target = symbolToNode.get(occ.symbol);
+      if (!target) continue;
+      const line = (occ.range[0] ?? 0) + 1;
+      const src = enclosing(fileNodes, line);
+      if (!src || src.id === target.id) continue;
+      const kind = target.kind === "function" || target.kind === "method" ? "call" : "references";
+      add(edgeMap, kind, src.id, target.id);
+      resolved++;
+    }
+  }
+  return {
+    edges: [...edgeMap.values()],
+    coveredFiles,
+    stats: { documents: index.documents.length, references, resolved }
+  };
+}
+function add(map, kind, src, dst) {
+  const id = edgeId(kind, src, dst);
+  const existing = map.get(id);
+  if (existing) {
+    existing.count = (existing.count ?? 1) + 1;
+    return;
+  }
+  const resolution = "scip";
+  map.set(id, { id, kind, src, dst, resolution, confidence: 1, count: 1 });
+}
+function enclosing(nodes, line) {
+  let best;
+  for (const n of nodes) {
+    if (n.span.start <= line && n.span.end >= line) {
+      if (!best || n.span.end - n.span.start < best.span.end - best.span.start) best = n;
+    }
+  }
+  return best;
+}
+function nodeStartingAt(nodes, line) {
+  let best;
+  for (const n of nodes) {
+    if (n.span.start === line) {
+      if (!best || n.span.end - n.span.start < best.span.end - best.span.start) best = n;
+    }
+  }
+  return best;
+}
+
+// src/engine/rng.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function() {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+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 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 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 = 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);
+  const vals = [...importanceN.values()];
+  const mean = vals.reduce((a, b) => a + b, 0) / (vals.length || 1);
+  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 } = tier === "xl" ? clusterFileLevel(nodes, edges, mode) : cluster(ids, edges, mode);
+  const outNodes = nodes.map((n) => ({
+    ...n,
+    centrality: {
+      degree: round(degN.get(n.id) ?? 0),
+      pagerank: round(prN.get(n.id) ?? 0),
+      betweenness: round(bwN.get(n.id) ?? 0),
+      eigenvector: round(evN.get(n.id) ?? 0)
+    },
+    importance: round(importanceN.get(n.id) ?? 0),
+    area: areaByNode.get(n.id) ?? -1,
+    isHub: (importanceN.get(n.id) ?? 0) >= hubThreshold && (importanceN.get(n.id) ?? 0) > 0
+  })).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, 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 });
+  for (const id of ids) g.addNode(id);
+  for (const e of edges) {
+    if (!kinds.has(e.kind)) continue;
+    if (e.src === e.dst) continue;
+    if (!g.hasNode(e.src) || !g.hasNode(e.dst)) continue;
+    const w = (e.confidence || 0.5) * (e.count ?? 1);
+    if (type === "directed") {
+      g.updateDirectedEdge(e.src, e.dst, (attr) => ({ weight: (attr?.weight ?? 0) + w }));
+    } else {
+      g.updateUndirectedEdge(e.src, e.dst, (attr) => ({ weight: (attr?.weight ?? 0) + w }));
+    }
+  }
+  return g;
+}
+function cluster(ids, edges, mode) {
+  if (mode === "none" || ids.length === 0) {
+    return { areaByNode: new Map(ids.map((id) => [id, -1])), mode: "none" };
+  }
+  const used = "louvain";
+  const ug = simpleGraph(ids, edges, CLUSTER_EDGE_KINDS, "undirected");
+  let communities;
+  try {
+    communities = louvain(ug, { rng: mulberry32(CLUSTER_SEED), resolution: 1 });
+  } catch {
+    return { areaByNode: new Map(ids.map((id) => [id, -1])), mode: "none" };
+  }
+  const byCommunity = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const ci = communities[id] ?? -1;
+    const list = byCommunity.get(ci);
+    if (list) list.push(id);
+    else byCommunity.set(ci, [id]);
+  }
+  const ordered = [...byCommunity.entries()].map(([, members]) => members.sort((a, b) => a.localeCompare(b))).sort((a, b) => a[0].localeCompare(b[0]));
+  const areaByNode = /* @__PURE__ */ new Map();
+  ordered.forEach((members, areaId) => {
+    for (const id of members) areaByNode.set(id, areaId);
+  });
+  return { areaByNode, mode: used };
+}
+function buildAreas(nodes, edges, areaByNode) {
+  const byArea = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const a = areaByNode.get(n.id) ?? -1;
+    if (a < 0) continue;
+    const list = byArea.get(a);
+    if (list) list.push(n);
+    else byArea.set(a, [n]);
+  }
+  const externalByArea = /* @__PURE__ */ new Map();
+  const internalByArea = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!DEP_EDGES.has(e.kind)) continue;
+    const sa = areaByNode.get(e.src);
+    const da = areaByNode.get(e.dst);
+    if (sa === void 0 || da === void 0 || sa < 0 || da < 0) continue;
+    if (sa === da) internalByArea.set(sa, (internalByArea.get(sa) ?? 0) + 1);
+    else {
+      externalByArea.set(sa, (externalByArea.get(sa) ?? 0) + 1);
+      externalByArea.set(da, (externalByArea.get(da) ?? 0) + 1);
+    }
+  }
+  const areas = [];
+  for (const [id, members] of byArea) {
+    const sorted = [...members].sort(
+      (a, b) => b.importance - a.importance || a.id.localeCompare(b.id)
+    );
+    const label = sorted[0]?.qualifiedName ?? `area-${id}`;
+    const internal = internalByArea.get(id) ?? 0;
+    const external = externalByArea.get(id) ?? 0;
+    const cohesion = internal + external > 0 ? internal / (internal + external) : 0;
+    areas.push({
+      id,
+      label,
+      size: members.length,
+      members: members.map((m) => m.id).sort((a, b) => a.localeCompare(b)),
+      cohesion: round(cohesion),
+      externalEdges: external
+    });
+  }
+  return areas.sort((a, b) => a.id - b.id);
+}
+function scoreSurprise(edges, areaByNode) {
+  const pairCount = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!DEP_EDGES.has(e.kind)) continue;
+    const sa = areaByNode.get(e.src);
+    const da = areaByNode.get(e.dst);
+    if (sa === void 0 || da === void 0 || sa < 0 || da < 0 || sa === da) continue;
+    const key = pairKey(sa, da);
+    pairCount.set(key, (pairCount.get(key) ?? 0) + 1);
+  }
+  return edges.map((e) => {
+    if (!DEP_EDGES.has(e.kind)) return e;
+    const sa = areaByNode.get(e.src);
+    const da = areaByNode.get(e.dst);
+    if (sa === void 0 || da === void 0 || sa < 0 || da < 0 || sa === da) return e;
+    const count = pairCount.get(pairKey(sa, da)) ?? 1;
+    return { ...e, surprise: round(1 / count) };
+  }).sort(
+    (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
+  );
+}
+function safeMetric(fn, ids) {
+  try {
+    const res = fn();
+    return new Map(ids.map((id) => [id, res[id] ?? 0]));
+  } catch {
+    return zeros(ids);
+  }
+}
+function degreeMap(g, ids) {
+  return new Map(ids.map((id) => [id, g.hasNode(id) ? g.degree(id) : 0]));
+}
+function zeros(ids) {
+  return new Map(ids.map((id) => [id, 0]));
+}
+function normalize(m) {
+  let max = 0;
+  for (const v of m.values()) if (v > max) max = v;
+  if (max <= 0) return new Map(m);
+  return new Map([...m].map(([k, v]) => [k, v / max]));
+}
+function round(x) {
+  return Math.round(x * 1e6) / 1e6;
+}
+function pairKey(a, b) {
+  return a < b ? `${a}|${b}` : `${b}|${a}`;
+}
+var DEFAULT_PATHS = [
+  "coverage/lcov.info",
+  "lcov.info",
+  "coverage/coverage-final.json",
+  "coverage-final.json"
+];
+function loadCoverage(root, explicit) {
+  const candidates = (explicit && explicit.length ? explicit : DEFAULT_PATHS).map(
+    (p) => path10.resolve(root, p)
+  );
+  const found = candidates.filter((p) => fs10.existsSync(p));
+  if (found.length === 0) return null;
+  const map = /* @__PURE__ */ new Map();
+  for (const file of found) {
+    try {
+      const text = fs10.readFileSync(file, "utf8");
+      if (file.endsWith(".json")) mergeIstanbul(map, text, root);
+      else mergeLcov(map, text, root);
+    } catch {
+    }
+  }
+  return map.size ? map : null;
+}
+function rel(root, p) {
+  const abs = path10.isAbsolute(p) ? p : path10.resolve(root, p);
+  return path10.relative(root, abs).split(path10.sep).join("/");
+}
+function bump(map, file, line, hits) {
+  let lh = map.get(file);
+  if (!lh) {
+    lh = /* @__PURE__ */ new Map();
+    map.set(file, lh);
+  }
+  lh.set(line, Math.max(lh.get(line) ?? 0, hits));
+}
+function mergeLcov(map, text, root) {
+  let current = null;
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("SF:")) current = rel(root, line.slice(3));
+    else if (line.startsWith("DA:") && current) {
+      const [ln, hits] = line.slice(3).split(",");
+      const n = Number(ln);
+      const h = Number(hits);
+      if (Number.isFinite(n)) bump(map, current, n, Number.isFinite(h) ? h : 0);
+    } else if (line === "end_of_record") current = null;
+  }
+}
+function mergeIstanbul(map, text, root) {
+  const data = JSON.parse(text);
+  for (const [key, entry] of Object.entries(data)) {
+    const file = rel(root, entry.path ?? key);
+    const stmts = entry.statementMap ?? {};
+    const counts = entry.s ?? {};
+    for (const [id, loc] of Object.entries(stmts)) {
+      const hits = counts[id] ?? 0;
+      const start = loc.start?.line;
+      const end = loc.end?.line ?? start;
+      if (!Number.isFinite(start)) continue;
+      for (let ln = start; ln <= end; ln++) bump(map, file, ln, hits);
+    }
+  }
+}
+function applyCoverage(nodes, coverage) {
+  return nodes.map((n) => {
+    if (n.kind === "file" || n.kind === "external") return n;
+    const lh = coverage.get(n.file);
+    if (!lh) return n;
+    let instrumented = 0;
+    let covered = 0;
+    for (let ln = n.span.start; ln <= n.span.end; ln++) {
+      const hits = lh.get(ln);
+      if (hits === void 0) continue;
+      instrumented++;
+      if (hits > 0) covered++;
+    }
+    if (instrumented === 0) return n;
+    const fraction = Math.round(covered / instrumented * 1e6) / 1e6;
+    const tested = covered > 0 ? true : n.kind === "function" || n.kind === "method" ? false : n.tested;
+    return { ...n, coverage: fraction, tested };
+  });
+}
+
+// src/engine/facts.ts
+function buildFacts(parses, nodes, edges) {
+  const facts = [];
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const defsByFile = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    const list = defsByFile.get(n.file);
+    if (list) list.push(n);
+    else defsByFile.set(n.file, [n]);
+  }
+  for (const n of nodes) {
+    if ((n.kind === "function" || n.kind === "method") && n.signature) {
+      facts.push(makeFact("contract", [n.id], { signature: n.signature }, "declared", "Observed", [
+        { file: n.file, span: n.span }
+      ]));
+    }
+  }
+  for (const p of parses) {
+    const defs = defsByFile.get(p.rel);
+    if (!defs) continue;
+    for (const g of p.guards) {
+      const owner = enclosing2(defs, g.line);
+      if (!owner) continue;
+      facts.push(
+        makeFact("invariant", [owner.id], { guard: g.expr }, "static", "Derived", [
+          { file: p.rel, span: { start: g.line, end: g.line } }
+        ])
+      );
+    }
+  }
+  const testsByNode = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.kind !== "test") continue;
+    const testFile = byId.get(e.src)?.file;
+    if (!testFile) continue;
+    const list = testsByNode.get(e.dst);
+    if (list) list.push(testFile);
+    else testsByNode.set(e.dst, [testFile]);
+  }
+  for (const [nodeId2, testFiles] of testsByNode) {
+    const n = byId.get(nodeId2);
+    if (!n) continue;
+    facts.push(
+      makeFact(
+        "characterization",
+        [nodeId2],
+        { pinnedBy: [...new Set(testFiles)].sort() },
+        "static",
+        "Observed",
+        [{ file: n.file, span: n.span }]
+      )
+    );
+  }
+  return facts.sort((a, b) => a.id.localeCompare(b.id));
+}
+function makeFact(kind, subjectIds, predicate, derivedBy, confidence, evidence) {
+  const id = shortId(canonicalize({ t: "fact", kind, subjectIds, predicate }));
+  return { id, kind, subjectIds, predicate, derivedBy, confidence, evidence };
+}
+function enclosing2(defs, line) {
+  let best;
+  for (const d of defs) {
+    if (d.span.start <= line && d.span.end >= line) {
+      if (!best || d.span.end - d.span.start < best.span.end - best.span.start) best = d;
+    }
+  }
+  return best;
+}
+
+// src/engine/grounding.ts
+function groundGraph(nodes, edges, parses, packs = [FREE_PACK]) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const importsByFile = /* @__PURE__ */ new Map();
+  for (const p of parses) importsByFile.set(p.rel, p.imports.map((i) => i.source.toLowerCase()));
+  const calleesByNode = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.kind !== "call") continue;
+    const callee = byId.get(e.dst)?.name;
+    if (!callee) continue;
+    const list = calleesByNode.get(e.src);
+    if (list) list.push(callee.toLowerCase());
+    else calleesByNode.set(e.src, [callee.toLowerCase()]);
+  }
+  const out = [];
+  for (const n of nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    const nameParts = new Set(
+      n.name.split(/[^a-zA-Z0-9]+|(?<=[a-z])(?=[A-Z])/).filter(Boolean).map((s) => s.toLowerCase())
+    );
+    const imports = importsByFile.get(n.file) ?? [];
+    const callees = calleesByNode.get(n.id) ?? [];
+    for (const pack of packs) {
+      for (const entry of pack.entries) {
+        const conf = matchConfidence(entry, nameParts, imports, callees);
+        if (conf > 0) {
+          out.push({
+            src: n.id,
+            packEntryId: entry.id,
+            kind: entry.kind,
+            confidence: conf,
+            rationale: entry.rationale,
+            citation: entry.citation
+          });
+        }
+      }
+    }
+  }
+  return out.sort(
+    (a, b) => a.src.localeCompare(b.src) || a.packEntryId.localeCompare(b.packEntryId)
+  );
+}
+function matchConfidence(entry, nameParts, imports, callees) {
+  let conf = 0;
+  if (entry.match.imports) {
+    for (const sig of entry.match.imports) {
+      if (imports.some((imp) => imp.includes(sig.toLowerCase()))) {
+        conf = Math.max(conf, 0.8);
+        break;
+      }
+    }
+  }
+  if (entry.match.calls) {
+    const want = new Set(entry.match.calls.map((s) => s.toLowerCase()));
+    if (callees.some((c) => want.has(c))) conf = Math.max(conf, 0.7);
+  }
+  if (entry.match.keywords) {
+    if (entry.match.keywords.some((k) => nameParts.has(k.toLowerCase()))) {
+      conf = Math.max(conf, 0.5);
+    }
+  }
+  return conf;
+}
+var DEFAULT_INLINE_THRESHOLD = 24;
+async function parseFiles(files, options = {}) {
+  const threshold = options.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
+  const cores = Math.max(1, os.cpus()?.length ?? 1);
+  const jobs = Math.max(1, options.jobs ?? envJobs() ?? (Math.min(cores - 1, files.length) || 1));
+  const workerFile = resolveWorkerFile();
+  const useInline = options.inline === true || jobs <= 1 || files.length < threshold || workerFile === null;
+  if (useInline) {
+    if (options.grammarsDir) setGrammarsOverride(options.grammarsDir);
+    return sortByRel(await parseInline(files, options));
+  }
+  return sortByRel(await parsePooled(files, jobs, workerFile, options));
+}
+var MEM_CHECK_EVERY = 64;
+async function parseInline(files, options) {
+  const { onProgress, memoryBudgetMb = 0 } = options;
+  const out = [];
+  onProgress?.(0, files.length);
+  for (const file of files) {
+    try {
+      const source = fs10.readFileSync(file.abs, "utf8");
+      out.push(await parseSource(file.rel, file.lang.id, source));
+    } catch (err) {
+      out.push(emptyParse(file, `parse failed: ${err.message}`));
+    }
+    onProgress?.(out.length, files.length);
+    if (out.length % MEM_CHECK_EVERY === 0) checkMemoryBudget("parse", memoryBudgetMb);
+  }
+  return out;
+}
+async function parsePooled(files, jobs, workerFile, options) {
+  const { onProgress, grammarsDir, memoryBudgetMb = 0 } = options;
+  const { default: Tinypool } = await import('tinypool');
+  const workerHeapMb = envWorkerHeapMb();
+  const pool = new Tinypool({
+    filename: workerFile,
+    maxThreads: jobs,
+    minThreads: 1,
+    ...workerHeapMb ? { resourceLimits: { maxOldGenerationSizeMb: workerHeapMb } } : {}
+  });
+  try {
+    const total = files.length;
+    const buckets = chunk(
+      files.map((f) => ({ rel: f.rel, abs: f.abs, lang: f.lang.id })),
+      Math.min(total, jobs * 8)
+    );
+    let done = 0;
+    onProgress?.(0, total);
+    const results = await Promise.all(
+      buckets.map(
+        (b) => pool.run({ tasks: b, grammarsDir }).then((r) => {
+          done += b.length;
+          onProgress?.(done, total);
+          checkMemoryBudget("parse", memoryBudgetMb);
+          return r;
+        })
+      )
+    );
+    return results.flat();
+  } catch (err) {
+    if (isWorkerOom(err)) {
+      throw new ResourceLimitError(
+        `graph build stopped: a parse worker exceeded its ${workerHeapMb ?? "?"} MiB heap cap (VG_WORKER_HEAP_MB). Raise the cap, exclude the offending files (--exclude), or run single-threaded with --jobs 1.`
+      );
+    }
+    throw err;
+  } finally {
+    await pool.destroy();
+  }
+}
+function isWorkerOom(err) {
+  const e = err;
+  return e?.code === "ERR_WORKER_OUT_OF_MEMORY" || /out of memory/i.test(e?.message ?? "");
+}
+function resolveWorkerFile() {
+  const here = path10.dirname(fileURLToPath(import.meta.url));
+  const candidate = path10.join(here, "parse-worker.js");
+  return fs10.existsSync(candidate) ? candidate : null;
+}
+function chunk(items, buckets) {
+  const out = Array.from({ length: Math.min(buckets, items.length || 1) }, () => []);
+  if (out.length === 0) return [];
+  items.forEach((item, i) => out[i % out.length].push(item));
+  return out.filter((c) => c.length > 0);
+}
+function sortByRel(parses) {
+  return parses.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+}
+function emptyParse(file, warning) {
+  return {
+    rel: file.rel,
+    lang: file.lang.id,
+    hash: "",
+    bytes: 0,
+    defs: [],
+    calls: [],
+    imports: [],
+    heritage: [],
+    typeRefs: [],
+    guards: [],
+    warnings: [warning]
+  };
+}
+var PRECISE_KIND = "tsc";
+function tsResolveEdges(root, tsFiles, nodes) {
+  const empty = {
+    edges: [],
+    coveredFiles: /* @__PURE__ */ new Set(),
+    stats: { files: 0, calls: 0, jsx: 0, heritage: 0, resolved: 0 }
+  };
+  if (tsFiles.length === 0) return empty;
+  const absToRel = new Map(tsFiles.map((f) => [normalize2(f.abs), f.rel]));
+  const options = compilerOptions(root);
+  let program;
+  try {
+    program = ts.createProgram(tsFiles.map((f) => f.abs), options);
+  } catch {
+    return empty;
+  }
+  const checker = program.getTypeChecker();
+  const nodesByFile = /* @__PURE__ */ new Map();
+  const fileNodeByRel = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file") {
+      fileNodeByRel.set(n.file, n);
+      continue;
+    }
+    if (n.kind === "external") continue;
+    const list = nodesByFile.get(n.file);
+    if (list) list.push(n);
+    else nodesByFile.set(n.file, [n]);
+  }
+  const relForAbs = (abs) => absToRel.get(normalize2(abs));
+  const edges = /* @__PURE__ */ new Map();
+  const covered = /* @__PURE__ */ new Set();
+  const stats = empty.stats;
+  const interfaceCalls = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const list of nodesByFile.values()) for (const n of list) byId.set(n.id, n);
+  for (const file of tsFiles) {
+    const sf = program.getSourceFile(file.abs);
+    if (!sf) continue;
+    covered.add(file.rel);
+    stats.files++;
+    const fileNodes = nodesByFile.get(file.rel) ?? [];
+    const fileNode = fileNodeByRel.get(file.rel);
+    const lineOf = (pos) => sf.getLineAndCharacterOfPosition(pos).line + 1;
+    const visit = (node) => {
+      if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+        stats.calls++;
+        const target = resolveTarget(checker, node.expression, nodesByFile, relForAbs);
+        if (target) {
+          const src = enclosing3(fileNodes, lineOf(node.getStart(sf))) ?? fileNode;
+          if (src && src.id !== target.id) {
+            add2(edges, callKind(target), src.id, target.id);
+            stats.resolved++;
+            if (target.kind === "interface" && ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+              interfaceCalls.push({ srcId: src.id, interfaceId: target.id, method: node.expression.name.text });
+            }
+          }
+        }
+      } else if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+        if (isComponentTag(node.tagName)) {
+          stats.jsx++;
+          const target = resolveTarget(checker, node.tagName, nodesByFile, relForAbs);
+          if (target) {
+            const src = enclosing3(fileNodes, lineOf(node.getStart(sf))) ?? fileNode;
+            if (src && src.id !== target.id) {
+              add2(edges, callKind(target), src.id, target.id);
+              stats.resolved++;
+            }
+          }
+        }
+      } else if (ts.isClassDeclaration(node) && node.heritageClauses) {
+        const classLine = lineOf(node.getStart(sf));
+        const src = enclosing3(fileNodes, classLine);
+        for (const clause of node.heritageClauses) {
+          const kind = clause.token === ts.SyntaxKind.ImplementsKeyword ? "implements" : "extends";
+          for (const t of clause.types) {
+            stats.heritage++;
+            const target = resolveTarget(checker, t.expression, nodesByFile, relForAbs);
+            if (src && target && src.id !== target.id) {
+              add2(edges, kind, src.id, target.id);
+              stats.resolved++;
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sf);
+  }
+  const implsByInterface = /* @__PURE__ */ new Map();
+  for (const e of edges.values()) {
+    if (e.kind !== "implements" && e.kind !== "extends") continue;
+    if (byId.get(e.dst)?.kind !== "interface") continue;
+    const list = implsByInterface.get(e.dst);
+    if (list) list.push(e.src);
+    else implsByInterface.set(e.dst, [e.src]);
+  }
+  for (const { srcId, interfaceId, method } of interfaceCalls) {
+    const impls = implsByInterface.get(interfaceId);
+    if (!impls || impls.length !== 1) continue;
+    const impl = byId.get(impls[0]);
+    if (!impl) continue;
+    const target = (nodesByFile.get(impl.file) ?? []).find(
+      (n) => (n.kind === "method" || n.kind === "function") && n.qualifiedName === `${impl.qualifiedName}.${method}`
+    );
+    if (target && target.id !== srcId) {
+      add2(edges, "call", srcId, target.id);
+      stats.resolved++;
+    }
+  }
+  return { edges: [...edges.values()], coveredFiles: covered, stats };
+}
+function callKind(target) {
+  return target.kind === "function" || target.kind === "method" || target.kind === "class" || target.kind === "component" ? "call" : "references";
+}
+function isComponentTag(tag) {
+  if (ts.isIdentifier(tag)) return /^[A-Z]/.test(tag.text);
+  return ts.isPropertyAccessExpression(tag);
+}
+function resolveTarget(checker, expr, nodesByFile, relForAbs) {
+  let sym = checker.getSymbolAtLocation(expr);
+  if (!sym) return null;
+  if (sym.flags & ts.SymbolFlags.Alias) {
+    try {
+      sym = checker.getAliasedSymbol(sym);
+    } catch {
+    }
+  }
+  const decls = sym.declarations;
+  if (!decls) return null;
+  for (const decl of decls) {
+    const df = decl.getSourceFile();
+    const rel2 = relForAbs(df.fileName);
+    if (!rel2) continue;
+    const fileNodes = nodesByFile.get(rel2);
+    if (!fileNodes) continue;
+    const line = df.getLineAndCharacterOfPosition(decl.getStart(df)).line + 1;
+    const node = pickNode(fileNodes, line, expectedKinds(decl));
+    if (node) return node;
+  }
+  return null;
+}
+function expectedKinds(decl) {
+  if (ts.isMethodDeclaration(decl) || ts.isMethodSignature(decl)) return /* @__PURE__ */ new Set(["method"]);
+  if (ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl) || ts.isArrowFunction(decl)) {
+    return /* @__PURE__ */ new Set(["function", "method", "component"]);
+  }
+  if (ts.isClassDeclaration(decl) || ts.isClassExpression(decl)) return /* @__PURE__ */ new Set(["class", "component"]);
+  if (ts.isInterfaceDeclaration(decl)) return /* @__PURE__ */ new Set(["interface"]);
+  if (ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl) || ts.isGetAccessorDeclaration(decl) || ts.isSetAccessorDeclaration(decl)) {
+    return /* @__PURE__ */ new Set(["property", "method"]);
+  }
+  if (ts.isConstructorDeclaration(decl)) return /* @__PURE__ */ new Set(["class", "method"]);
+  if (ts.isVariableDeclaration(decl)) return /* @__PURE__ */ new Set(["function", "property", "component"]);
+  return /* @__PURE__ */ new Set();
+}
+function pickNode(nodes, line, want) {
+  let best;
+  for (const n of nodes) {
+    if (n.span.start !== line) continue;
+    if (!best || better(n, best, want)) best = n;
+  }
+  return best ?? enclosing3(nodes, line);
+}
+function better(n, best, want) {
+  const nWanted = want.has(n.kind);
+  const bWanted = want.has(best.kind);
+  if (nWanted !== bWanted) return nWanted;
+  const nSize = n.span.end - n.span.start;
+  const bSize = best.span.end - best.span.start;
+  if (nSize !== bSize) return nSize < bSize;
+  return n.id < best.id;
+}
+function compilerOptions(root) {
+  const base = {
+    allowJs: true,
+    checkJs: false,
+    skipLibCheck: true,
+    noEmit: true,
+    noResolve: false,
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.Preserve,
+    allowImportingTsExtensions: true,
+    resolveJsonModule: true
+  };
+  const configPath = ts.findConfigFile(root, ts.sys.fileExists, "tsconfig.json") ?? ts.findConfigFile(root, ts.sys.fileExists, "tsconfig.base.json");
+  if (configPath) {
+    try {
+      const host = {
+        ...ts.sys,
+        onUnRecoverableConfigFileDiagnostic: () => {
+        }
+      };
+      const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, host);
+      if (parsed) {
+        return { ...parsed.options, ...base, baseUrl: parsed.options.baseUrl, paths: parsed.options.paths };
+      }
+    } catch {
+    }
+  }
+  return base;
+}
+function add2(map, kind, src, dst) {
+  const id = edgeId(kind, src, dst);
+  const existing = map.get(id);
+  if (existing) {
+    existing.count = (existing.count ?? 1) + 1;
+    return;
+  }
+  map.set(id, { id, kind, src, dst, resolution: PRECISE_KIND, confidence: 1, count: 1 });
+}
+function enclosing3(nodes, line) {
+  let best;
+  for (const n of nodes) {
+    if (n.span.start <= line && n.span.end >= line) {
+      if (!best || n.span.end - n.span.start < best.span.end - best.span.start) best = n;
+    }
+  }
+  return best;
+}
+function normalize2(p) {
+  return path10.resolve(p).split(path10.sep).join("/");
+}
+
+// src/engine/epistemic.ts
+var SEMANTIC_RESOLVERS = /* @__PURE__ */ new Set(["scip", "stackgraph", "tsc"]);
+function classifyEpistemic(edge, dstKind) {
+  if (SEMANTIC_RESOLVERS.has(edge.resolution)) return "observed";
+  switch (edge.kind) {
+    case "contains":
+      return "observed";
+    case "import":
+      return dstKind === "external" || dstKind === void 0 ? "declared" : "observed";
+    case "test":
+    case "coverage":
+      return "declared";
+    default:
+      return "name-matched";
+  }
+}
+function epistemicBreakdown(edges) {
+  const out = { observed: 0, "name-matched": 0, declared: 0 };
+  for (const e of edges) {
+    if (e.epistemic) out[e.epistemic]++;
+  }
+  return out;
+}
+var DOC_BODY_MAX_CHARS = 8e3;
+var DOC_FILE_MAX_BYTES = 512 * 1024;
+var DOC_MAX_FILES = 600;
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst", ".adoc"]);
+var ENV_EXAMPLE_NAMES = /* @__PURE__ */ new Set([
+  "example.env",
+  "env.example",
+  ".env.example",
+  ".env.sample",
+  ".env.template",
+  ".env.development.example",
+  ".env.local.example",
+  "dotenv.example"
+]);
+var EXACT_BASENAME = {
+  // Manifests / package managers
+  "package.json": "manifest",
+  "package.yaml": "manifest",
+  "package.yml": "manifest",
+  "pyproject.toml": "manifest",
+  "setup.cfg": "manifest",
+  "requirements.txt": "manifest",
+  "requirements-dev.txt": "manifest",
+  "pipfile": "manifest",
+  "go.mod": "manifest",
+  "go.work": "manifest",
+  "cargo.toml": "manifest",
+  "composer.json": "manifest",
+  "gemfile": "manifest",
+  "podfile": "manifest",
+  "pubspec.yaml": "manifest",
+  "mix.exs": "manifest",
+  "build.gradle": "manifest",
+  "build.gradle.kts": "manifest",
+  "settings.gradle": "manifest",
+  "settings.gradle.kts": "manifest",
+  "pom.xml": "manifest",
+  "project.clj": "manifest",
+  "stack.yaml": "manifest",
+  "package.swift": "manifest",
+  // Workspace / monorepo
+  "pnpm-workspace.yaml": "workspace",
+  "pnpm-workspace.yml": "workspace",
+  "lerna.json": "workspace",
+  "nx.json": "workspace",
+  "turbo.json": "workspace",
+  "rush.json": "workspace",
+  "workspace.json": "workspace",
+  // Docker
+  dockerfile: "docker",
+  "dockerfile.dev": "docker",
+  "dockerfile.prod": "docker",
+  "dockerfile.local": "docker",
+  containerfile: "docker",
+  // Compose
+  "docker-compose.yml": "compose",
+  "docker-compose.yaml": "compose",
+  "compose.yml": "compose",
+  "compose.yaml": "compose",
+  "docker-compose.dev.yml": "compose",
+  "docker-compose.prod.yml": "compose",
+  "docker-compose.override.yml": "compose",
+  // Task runners
+  makefile: "task-runner",
+  gnumakefile: "task-runner",
+  justfile: "task-runner",
+  "taskfile.yml": "task-runner",
+  "taskfile.yaml": "task-runner",
+  rakefile: "task-runner",
+  // Build / tool config (exact)
+  "tsconfig.json": "build-config",
+  "jsconfig.json": "build-config",
+  "vite.config.ts": "build-config",
+  "vite.config.js": "build-config",
+  "vite.config.mjs": "build-config",
+  "vitest.config.ts": "build-config",
+  "vitest.config.js": "build-config",
+  "jest.config.js": "build-config",
+  "jest.config.ts": "build-config",
+  "jest.config.cjs": "build-config",
+  "webpack.config.js": "build-config",
+  "webpack.config.ts": "build-config",
+  "rollup.config.js": "build-config",
+  "esbuild.config.js": "build-config",
+  "next.config.js": "build-config",
+  "next.config.mjs": "build-config",
+  "next.config.ts": "build-config",
+  "nuxt.config.ts": "build-config",
+  "nuxt.config.js": "build-config",
+  "astro.config.mjs": "build-config",
+  "svelte.config.js": "build-config",
+  "remix.config.js": "build-config",
+  "angular.json": "build-config",
+  "babel.config.js": "build-config",
+  "babel.config.json": "build-config",
+  ".babelrc": "build-config",
+  ".babelrc.js": "build-config",
+  ".babelrc.json": "build-config",
+  "eslint.config.js": "build-config",
+  "eslint.config.mjs": "build-config",
+  "eslint.config.cjs": "build-config",
+  "eslint.config.ts": "build-config",
+  ".eslintrc": "build-config",
+  ".eslintrc.js": "build-config",
+  ".eslintrc.cjs": "build-config",
+  ".eslintrc.json": "build-config",
+  ".eslintrc.yml": "build-config",
+  ".prettierrc": "build-config",
+  ".prettierrc.js": "build-config",
+  ".prettierrc.json": "build-config",
+  ".prettierrc.yml": "build-config",
+  "prettier.config.js": "build-config",
+  "prettier.config.cjs": "build-config",
+  "ruff.toml": "build-config",
+  ".ruff.toml": "build-config",
+  "pytest.ini": "build-config",
+  "tox.ini": "build-config",
+  "mypy.ini": "build-config",
+  ".mypy.ini": "build-config",
+  "phpunit.xml": "build-config",
+  "phpunit.xml.dist": "build-config",
+  // CI exact
+  "jenkinsfile": "ci",
+  ".gitlab-ci.yml": "ci",
+  ".travis.yml": "ci",
+  "azure-pipelines.yml": "ci",
+  "buildkite.yml": "ci",
+  "cloudbuild.yaml": "ci",
+  "appveyor.yml": "ci",
+  "circle.yml": "ci",
+  // Deploy / infra (root-level common names)
+  "vercel.json": "infra",
+  "netlify.toml": "infra",
+  "wrangler.toml": "infra",
+  "wrangler.json": "infra",
+  "wrangler.jsonc": "infra",
+  "fly.toml": "infra",
+  "railway.toml": "infra",
+  "render.yaml": "infra",
+  "app.yaml": "infra",
+  "Procfile": "infra",
+  "procfile": "infra",
+  "heroku.yml": "infra",
+  "serverless.yml": "infra",
+  "serverless.yaml": "infra",
+  "sam.yaml": "infra",
+  "samconfig.toml": "infra",
+  "cdk.json": "infra",
+  "pulumi.yaml": "infra",
+  "terraform.tf": "infra",
+  // Agent / project meta (also covered by .md extension)
+  "agents.md": "markdown",
+  "claude.md": "markdown",
+  "codeowners": "other-config",
+  ".nvmrc": "other-config",
+  ".node-version": "other-config",
+  ".python-version": "other-config",
+  "runtime.txt": "other-config",
+  ".tool-versions": "other-config",
+  "editorconfig": "other-config",
+  ".editorconfig": "other-config"
+};
+var BASENAME_PREFIX = [
+  { re: /^dockerfile(\.|$)/i, category: "docker" },
+  { re: /^docker-compose(\.|$)/i, category: "compose" },
+  { re: /^compose\.(ya?ml)$/i, category: "compose" },
+  { re: /^tsconfig(\..+)?\.json$/i, category: "build-config" },
+  { re: /^jsconfig(\..+)?\.json$/i, category: "build-config" },
+  { re: /^vite\.config\./i, category: "build-config" },
+  { re: /^vitest\.config\./i, category: "build-config" },
+  { re: /^jest\.config\./i, category: "build-config" },
+  { re: /^webpack\.config\./i, category: "build-config" },
+  { re: /^rollup\.config\./i, category: "build-config" },
+  { re: /^next\.config\./i, category: "build-config" },
+  { re: /^nuxt\.config\./i, category: "build-config" },
+  { re: /^astro\.config\./i, category: "build-config" },
+  { re: /^eslint\.config\./i, category: "build-config" },
+  { re: /^\.eslintrc/i, category: "build-config" },
+  { re: /^openapi\./i, category: "api-contract" },
+  { re: /^swagger\./i, category: "api-contract" },
+  { re: /^requirements(-\w+)?\.txt$/i, category: "manifest" },
+  { re: /^dockerfile/i, category: "docker" }
+];
+var PATH_PATTERNS = [
+  // GitHub Actions / workflows
+  { re: /^\.github\/workflows\/.+\.ya?ml$/i, category: "ci" },
+  { re: /^\.github\/actions\/.+/i, category: "ci" },
+  { re: /^\.circleci\/.+\.ya?ml$/i, category: "ci" },
+  { re: /^\.buildkite\/.+/i, category: "ci" },
+  // Helm / k8s (values + charts — not every template blob)
+  { re: /^charts\/[^/]+\/(chart\.ya?ml|values.*\.ya?ml)$/i, category: "infra" },
+  { re: /^deploy\/.+\.ya?ml$/i, category: "infra" },
+  { re: /^k8s\/.+\.ya?ml$/i, category: "infra" },
+  { re: /^kubernetes\/.+\.ya?ml$/i, category: "infra" },
+  { re: /^infra\/.+\.ya?ml$/i, category: "infra" },
+  { re: /^terraform\/.+\.tf$/i, category: "infra" },
+  // API contracts by path
+  { re: /(^|\/)(openapi|swagger)(\.|\/)/i, category: "api-contract" },
+  { re: /(^|\/)api(-)?(spec|schema|contracts?)\//i, category: "api-contract" }
+];
+var API_EXTENSIONS = /* @__PURE__ */ new Set([".graphql", ".gql", ".proto", ".avsc", ".thrift"]);
+var IMPORTANCE = {
+  markdown: 0.1,
+  text: 0.06,
+  "env-example": 0.12,
+  manifest: 0.16,
+  docker: 0.14,
+  compose: 0.15,
+  ci: 0.14,
+  "build-config": 0.11,
+  "api-contract": 0.13,
+  "task-runner": 0.13,
+  workspace: 0.14,
+  infra: 0.12,
+  "other-config": 0.08
+};
+function toPosix2(p) {
+  return p.split(path10.sep).join("/");
+}
+function buildRootIgnore2(root, exclude) {
+  const ig = ignore();
+  const gitignorePath = path10.join(root, ".gitignore");
+  if (fs10.existsSync(gitignorePath)) {
+    try {
+      ig.add(fs10.readFileSync(gitignorePath, "utf8"));
+    } catch {
+    }
+  }
+  if (exclude.length) ig.add(exclude);
+  return ig;
+}
+function classifyProjectContext(relOrName) {
+  const rel2 = relOrName.replace(/\\/g, "/");
+  const base = path10.basename(rel2);
+  const baseLower = base.toLowerCase();
+  if (/^\.env($|\.)/i.test(base) && !isEnvExampleName(baseLower)) return null;
+  if (SKIP_FILES.has(baseLower)) return null;
+  if (isEnvExampleName(baseLower)) return "env-example";
+  const exact = EXACT_BASENAME[baseLower] ?? EXACT_BASENAME[base];
+  if (exact) return exact;
+  for (const { re, category } of BASENAME_PREFIX) {
+    if (re.test(base)) return category;
+  }
+  for (const { re, category } of PATH_PATTERNS) {
+    if (re.test(rel2)) return category;
+  }
+  const ext = path10.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)) {
+    return "api-contract";
+  }
+  if (/^docker-compose\..+\.ya?ml$/i.test(base) || /^compose\..+\.ya?ml$/i.test(base)) {
+    return "compose";
+  }
+  return null;
+}
+function isEnvExampleName(baseLower) {
+  if (ENV_EXAMPLE_NAMES.has(baseLower)) return true;
+  if (/^(\.)?env\.(example|sample|template)(\.|$)/i.test(baseLower)) return true;
+  if (/^example\.env/i.test(baseLower)) return true;
+  return false;
+}
+function discoverDocs(options) {
+  const root = path10.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) => path10.resolve(root, p)) : [root]).filter(
+    (p) => fs10.existsSync(p)
+  );
+  const found = /* @__PURE__ */ new Map();
+  const consider = (abs) => {
+    if (found.size >= maxFiles) return;
+    const rel2 = toPosix2(path10.relative(root, abs));
+    if (!rel2 || rel2.startsWith("..")) return;
+    if (rootIg.ignores(rel2)) return;
+    const base = path10.basename(abs);
+    if (SKIP_FILES.has(base.toLowerCase())) return;
+    const category = classifyProjectContext(rel2);
+    if (!category) return;
+    try {
+      const st = fs10.statSync(abs);
+      if (!st.isFile() || st.size > DOC_FILE_MAX_BYTES) return;
+      if (st.size === 0) return;
+    } catch {
+      return;
+    }
+    found.set(rel2, { rel: rel2, abs, kind: category, category });
+  };
+  const walk = (dir, depth) => {
+    if (found.size >= maxFiles || depth > 12) return;
+    let entries;
+    try {
+      entries = fs10.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 = path10.join(dir, entry.name);
+      const rel2 = toPosix2(path10.relative(root, abs));
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (rel2 && rootIg.ignores(`${rel2}/`) && !rel2.startsWith(".github")) continue;
+        walk(abs, depth + 1);
+      } else if (entry.isFile()) {
+        consider(abs);
+      }
+    }
+  };
+  for (const scope of scopeAbs) {
+    try {
+      const st = fs10.statSync(scope);
+      if (st.isDirectory()) walk(scope, 0);
+      else if (st.isFile()) consider(scope);
+    } catch {
+    }
+  }
+  return [...found.values()].sort((a, b) => a.rel.localeCompare(b.rel));
+}
+function prepareDocBody(rel2, raw, category) {
+  const scrubbed = redactSecrets(raw);
+  if (scrubbed.length <= DOC_BODY_MAX_CHARS) return scrubbed;
+  if (category === "manifest" && path10.basename(rel2).toLowerCase() === "package.json") {
+    return summarizePackageJson(scrubbed);
+  }
+  if (category === "api-contract" && /\.(ya?ml|json)$/i.test(rel2)) {
+    return scrubbed.slice(0, DOC_BODY_MAX_CHARS);
+  }
+  if (category === "ci") {
+    return scrubbed.slice(0, DOC_BODY_MAX_CHARS);
+  }
+  return scrubbed.slice(0, DOC_BODY_MAX_CHARS);
+}
+function summarizePackageJson(raw) {
+  try {
+    const o = JSON.parse(raw);
+    const keep = {};
+    for (const k of [
+      "name",
+      "version",
+      "description",
+      "private",
+      "type",
+      "packageManager",
+      "engines",
+      "workspaces",
+      "scripts",
+      "dependencies",
+      "devDependencies",
+      "peerDependencies",
+      "optionalDependencies",
+      "main",
+      "bin",
+      "exports"
+    ]) {
+      if (o[k] !== void 0) keep[k] = o[k];
+    }
+    const s = JSON.stringify(keep, null, 2);
+    return s.length <= DOC_BODY_MAX_CHARS ? s : s.slice(0, DOC_BODY_MAX_CHARS);
+  } catch {
+    return raw.slice(0, DOC_BODY_MAX_CHARS);
+  }
+}
+function documentNodesFromDocs(docs) {
+  const nodes = [];
+  for (const d of docs) {
+    let raw = "";
+    try {
+      raw = fs10.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 = path10.basename(d.rel);
+    const qualifiedName = d.rel.replace(/\\/g, "/");
+    const id = nodeId({
+      kind: "document",
+      qualifiedName,
+      file: qualifiedName,
+      signature: category
+    });
+    const lineCount = Math.max(1, scrubbed.split("\n").length);
+    const langTag = category === "markdown" ? "md" : category === "env-example" ? "env" : category === "manifest" ? "manifest" : category === "docker" || category === "compose" ? "docker" : category === "ci" ? "ci" : category === "api-contract" ? "api" : category === "build-config" ? "config" : category === "task-runner" ? "task" : category === "workspace" ? "workspace" : category === "infra" ? "infra" : "txt";
+    nodes.push({
+      id,
+      kind: "document",
+      name,
+      qualifiedName,
+      file: qualifiedName,
+      span: { start: 1, end: lineCount },
+      lang: langTag,
+      signature: `document:${category}`,
+      doc: scrubbed,
+      importance: IMPORTANCE[category] ?? 0.05,
+      centrality: { degree: 0, pagerank: 0, betweenness: 0, eigenvector: 0 },
+      area: -1,
+      isHub: false,
+      tested: null
+    });
+  }
+  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 = path10.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 = path10.resolve(root);
+  while (true) {
+    if (fs10.existsSync(path10.join(dir, "tsconfig.json")) || fs10.existsSync(path10.join(dir, "tsconfig.base.json")) || fs10.existsSync(path10.join(dir, "package.json"))) {
+      const key = toPosix3(path10.relative(rootAbs, dir)) || ".";
+      cache.set(startDir, key);
+      return key;
+    }
+    if (dir === rootAbs || path10.dirname(dir) === dir) {
+      cache.set(startDir, ".");
+      return ".";
+    }
+    dir = path10.dirname(dir);
+  }
+}
+function toPosix3(p) {
+  return p.split(path10.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 = path10.resolve(root);
+  const ig = buildRootIgnore3(absRoot, opts.exclude ?? []);
+  const scopes = (opts.paths?.length ? opts.paths : ["."]).map((p) => path10.resolve(absRoot, p)).filter((p) => fs10.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 = path10.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(fs10.readFileSync(abs, "utf8"));
+  const pkgName = raw.name && String(raw.name).trim() || path10.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: path10.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 = fs10.readFileSync(abs, "utf8");
+  let moduleName = path10.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: path10.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 = path10.join(root, ".gitignore");
+  if (fs10.existsSync(gitignorePath)) {
+    try {
+      ig.add(fs10.readFileSync(gitignorePath, "utf8"));
+    } catch {
+    }
+  }
+  if (exclude.length) ig.add(exclude);
+  return ig;
+}
+function walkManifests(root, dir, ig, found) {
+  let entries;
+  try {
+    entries = fs10.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const abs = path10.join(dir, entry.name);
+    const rel2 = path10.relative(root, abs).split(path10.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 fs7.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 = path10.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(
+      `graph build stopped: ${files.length.toLocaleString()} files exceed the ${limits.maxFiles.toLocaleString()}-file limit. Scope the build (pass sub-paths, add --exclude globs, or --only <langs>), or set VG_MAX_FILES to raise the limit (0 disables it).`
+    );
+  }
+  checkMemoryBudget("discovery", limits.memoryBudgetMb);
+  const grammars = grammarSetVersion();
+  const cache = loadCache(root, {
+    toolVersion: VERSION,
+    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 = fs10.statSync(file.abs);
+    } catch {
+      continue;
+    }
+    if (limits.maxFileBytes > 0 && stat.size > limits.maxFileBytes) {
+      fileStats.push({
+        rel: file.rel,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        hash: hashString(`vg:oversize:${stat.size}`)
+      });
+      buildWarnings.push(
+        `${file.rel}: skipped \u2014 ${formatBytes(stat.size)} exceeds the ${formatBytes(limits.maxFileBytes)} per-file limit (set VG_MAX_FILE_BYTES to raise it, 0 to disable)`
+      );
+      continue;
+    }
+    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;
+    }
+    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 cached = cache.get(p.file.rel, r.hash);
+      if (cached) {
+        reused.push(cached);
+        cache.set(p.file.rel, cached, { 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,
+    onProgress: options.onParseProgress,
+    grammarsDir: options.grammarsDir,
+    memoryBudgetMb: limits.memoryBudgetMb
+  });
+  timer.end("parse");
+  checkMemoryBudget("parse", limits.memoryBudgetMb);
+  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();
+  const parses = [...reused, ...parsedNew].sort(
+    (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;
+  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 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 = {
+        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) {
+    const res = scipEdges(scip.index, resolved.nodes, toRepoRel);
+    edges = mergePreciseEdges(edges, res.edges, res.coveredFiles, nodeFileById);
+    for (const f of res.coveredFiles) preciseCoveredFiles.add(f);
+    if (!resolvers.includes("scip")) resolvers.unshift("scip");
+    scipStats = { ...res.stats, tool: scip.tool };
+  }
+  const linked = applyStaticTestLinkage(resolved.nodes, edges);
+  let nodes = linked.nodes;
+  const coverage = options.noCoverage ? null : loadCoverage(root, options.coverage);
+  if (coverage) nodes = applyCoverage(nodes, coverage);
+  const docs = discoverDocs({
+    root,
+    exclude: options.exclude,
+    paths: options.paths
+  });
+  for (const d of docs) {
+    try {
+      const st = fs10.statSync(d.abs);
+      const hash = hashBytes(fs10.readFileSync(d.abs));
+      hashes.set(d.rel, hash);
+      fileStats.push({ rel: d.rel, size: st.size, mtimeMs: st.mtimeMs, hash });
+    } catch {
+    }
+  }
+  const docNodes = documentNodesFromDocs(docs);
+  if (docNodes.length) nodes = [...nodes, ...docNodes];
+  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();
+  const corpusHash = computeCorpusHash(parses, hashes);
+  const nodeKindById = new Map(analysis.nodes.map((n) => [n.id, n.kind]));
+  for (const e of analysis.edges) {
+    e.epistemic = classifyEpistemic(e, nodeKindById.get(e.dst));
+  }
+  const toolchain = computeToolchain(grammars, resolvers);
+  const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const testsCount = linked.testFiles.length;
+  const untestedCount = analysis.nodes.filter(
+    (n) => (n.kind === "function" || n.kind === "method") && n.tested === false
+  ).length;
+  const graph = {
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt,
+    provenance: {
+      tool: "vg",
+      version: VERSION,
+      grammars: Object.fromEntries(languages.map((l) => [l, grammars])),
+      resolver: resolvers,
+      deep: options.deep ?? false,
+      corpusHash,
+      toolchain
+    },
+    meta: {
+      root: path10.basename(root) === "" ? "." : ".",
+      languages,
+      analysisTier: analysis.tier,
+      counts: {
+        nodes: analysis.nodes.length,
+        edges: analysis.edges.length,
+        areas: analysis.areas.length,
+        tests: testsCount,
+        untested: untestedCount
+      },
+      cluster: analysis.cluster,
+      edgeKinds
+    },
+    nodes: analysis.nodes,
+    edges: analysis.edges,
+    areas: analysis.areas
+  };
+  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;
+  graph.summaries = buildSummaries(graph);
+  {
+    const facts = buildFacts(parses, analysis.nodes, analysis.edges);
+    if (facts.length) graph.facts = facts;
+  }
+  if (!options.noGround) {
+    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: 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
+  };
+}
+function toRepoRel(p) {
+  return p.split("\\").join("/").replace(/^\.?\//, "");
+}
+function loadScipIndex(root, explicit) {
+  const candidates = [
+    explicit,
+    path10.join(root, "index.scip"),
+    path10.join(root, ".vibgrate", "index.scip")
+  ].filter((p) => Boolean(p));
+  for (const file of candidates) {
+    const abs = path10.isAbsolute(file) ? file : path10.resolve(root, file);
+    if (!fs10.existsSync(abs)) continue;
+    try {
+      const index = decodeScipIndex(new Uint8Array(fs10.readFileSync(abs)));
+      if (index.documents.length) {
+        return { index, tool: index.toolVersion ? `${index.toolName} ${index.toolVersion}` : index.toolName };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+var PRECISE_KINDS = /* @__PURE__ */ new Set(["call", "references", "extends", "implements"]);
+function mergePreciseEdges(base, precise, coveredFiles, nodeFileById) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of base) {
+    if (PRECISE_KINDS.has(e.kind) && e.resolution === "heuristic") {
+      const srcFile = nodeFileById.get(e.src);
+      if (srcFile && coveredFiles.has(srcFile)) continue;
+    }
+    byId.set(e.id, e);
+  }
+  for (const e of precise) byId.set(e.id, e);
+  return [...byId.values()].sort(
+    (a, b) => a.kind.localeCompare(b.kind) || a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst)
+  );
+}
+function computeToolchain(grammars, resolvers) {
+  const sortedResolvers = [...new Set(resolvers)].sort();
+  return {
+    schema: SCHEMA_VERSION,
+    tool: VERSION,
+    grammars,
+    resolvers: sortedResolvers,
+    fingerprint: shortId(
+      canonicalize({
+        schema: SCHEMA_VERSION,
+        tool: VERSION,
+        grammars,
+        resolvers: sortedResolvers
+      })
+    )
+  };
+}
+function computeCorpusHash(parses, hashes) {
+  const fromParses = parses.map((p) => [p.rel, hashes.get(p.rel) ?? p.hash]);
+  const fromHashes = [...hashes.entries()].map(([rel2, hash]) => [rel2, hash]);
+  const byRel = /* @__PURE__ */ new Map();
+  for (const [rel2, hash] of [...fromParses, ...fromHashes]) byRel.set(rel2, hash);
+  const list = [...byRel.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  return hashString(canonicalize(list));
+}
+
+// src/engine/verify.ts
+var PINNED = "1970-01-01T00:00:00.000Z";
+async function verifyDeterminism(opts) {
+  const base = { root: opts.root, only: opts.only, exclude: opts.exclude, generatedAt: PINNED };
+  const buildA = await buildGraph({ ...base, noCache: true, jobs: opts.jobs });
+  const a = serializeGraph(buildA.graph);
+  const b = serializeGraph((await buildGraph({ ...base, noCache: true, jobs: 1 })).graph);
+  const cached = serializeGraph((await buildGraph({ ...base, noCache: false })).graph);
+  const checks = [
+    { name: "run-to-run determinism", ok: a === b, detail: diffHint(a, b) },
+    { name: "cache safety (incremental == full)", ok: a === cached, detail: diffHint(a, cached) }
+  ];
+  const scoped = Boolean(opts.only?.length || opts.exclude?.length);
+  const committed = scoped ? null : loadGraph(opts.root);
+  const committedFp = committed?.provenance.toolchain?.fingerprint;
+  const currentFp = buildA.graph.provenance.toolchain?.fingerprint;
+  if (committedFp && currentFp) {
+    const ok = committedFp === currentFp;
+    checks.push({
+      name: "toolchain fingerprint matches committed graph",
+      ok,
+      detail: ok ? void 0 : `committed toolchain ${committedFp} != current ${currentFp} (grammar/resolver versions differ \u2014 rebuild or align the toolchain)`
+    });
+  }
+  return {
+    ok: checks.every((c) => c.ok),
+    checks,
+    digest: hashString(a)
+  };
+}
+function diffHint(x, y) {
+  if (x === y) return void 0;
+  const xl = x.split("\n");
+  const yl = y.split("\n");
+  const n = Math.max(xl.length, yl.length);
+  for (let i = 0; i < n; i++) {
+    if (xl[i] !== yl[i]) {
+      return `first divergence at line ${i + 1}`;
+    }
+  }
+  return "outputs differ in length";
+}
+
+// src/util/exit.ts
+var ExitCode = {
+  OK: 0,
+  ERROR: 1,
+  GATE_FAILED: 2,
+  NOT_FOUND: 3,
+  NON_DETERMINISTIC: 4,
+  USAGE_ERROR: 5
+};
+var CliError = class extends Error {
+  code;
+  constructor(message, code = ExitCode.ERROR) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+  }
+};
+function usageError(message) {
+  return new CliError(message, ExitCode.USAGE_ERROR);
+}
+var SNAPSHOT_VERSION = "vg-freshness/1";
+function snapshotPath(root) {
+  return path10.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 {
+    fs10.mkdirSync(cacheDir(root), { recursive: true });
+    fs10.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+  } catch {
+  }
+}
+function loadSnapshot(root) {
+  try {
+    const loaded = JSON.parse(fs10.readFileSync(snapshotPath(root), "utf8"));
+    if (loaded.version === SNAPSHOT_VERSION && loaded.files && typeof loaded.corpusHash === "string") {
+      return { ...loaded, scope: loaded.scope ?? {} };
+    }
+  } catch {
+  }
+  return null;
+}
+function hasDrift(drift) {
+  return drift.changed.length + drift.added.length + drift.removed.length > 0;
+}
+function driftCount(drift) {
+  return drift.changed.length + drift.added.length + drift.removed.length;
+}
+function probeFreshness(root) {
+  const snapshot = loadSnapshot(root);
+  if (!snapshot) return null;
+  const { scope } = snapshot;
+  let discovered;
+  try {
+    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;
+  }
+  const drift = { changed: [], added: [], removed: [] };
+  const seen = /* @__PURE__ */ new Set();
+  let absorbed = false;
+  for (const file of discovered) {
+    seen.add(file.rel);
+    const entry = snapshot.files[file.rel];
+    if (!entry) {
+      drift.added.push(file.rel);
+      continue;
+    }
+    let stat;
+    try {
+      stat = fs10.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(fs10.readFileSync(file.abs));
+    } catch {
+      drift.removed.push(file.rel);
+      continue;
+    }
+    if (hash === entry.hash) {
+      snapshot.files[file.rel] = { size: stat.size, mtimeMs: stat.mtimeMs, hash };
+      absorbed = true;
+    } else {
+      drift.changed.push(file.rel);
+    }
+  }
+  for (const rel2 of Object.keys(snapshot.files)) {
+    if (!seen.has(rel2)) drift.removed.push(rel2);
+  }
+  if (absorbed && !hasDrift(drift)) {
+    try {
+      fs10.writeFileSync(snapshotPath(root), stableStringify(snapshot, 0));
+    } catch {
+    }
+  }
+  drift.changed.sort();
+  drift.added.sort();
+  drift.removed.sort();
+  return { drift, scope, corpusHash: snapshot.corpusHash };
+}
+function pruneScope(scope) {
+  const out = {};
+  if (scope.only?.length) out.only = [...scope.only].sort();
+  if (scope.exclude?.length) out.exclude = [...scope.exclude];
+  if (scope.paths?.length) out.paths = [...scope.paths];
+  if (scope.deep) out.deep = true;
+  if (scope.noGround) out.noGround = true;
+  if (scope.scip) out.scip = scope.scip;
+  if (scope.noScip) out.noScip = true;
+  if (scope.noTsc) out.noTsc = true;
+  if (scope.cluster) out.cluster = scope.cluster;
+  if (scope.grammarsDir) out.grammarsDir = scope.grammarsDir;
+  return out;
+}
+
+// src/install/content.ts
+var NUDGE_BEGIN = "<!-- vg:begin -->";
+var NUDGE_END = "<!-- vg:end -->";
+var INSTALL_CONTENT_VERSION = 2;
+var VERSION_MARKER_RE = /<!--\s*vg:v(\d+)\b[^>]*-->/;
+function versionMarker() {
+  return `<!-- vg:v${INSTALL_CONTENT_VERSION} \xB7 managed by \`vg install\` \u2014 auto-refreshed when these instructions evolve; remove this line to opt out -->`;
+}
+function installedContentVersion(text) {
+  const m = VERSION_MARKER_RE.exec(text);
+  return m ? Number(m[1]) : null;
+}
+function clientFlag(client) {
+  return client ? `--client=${client}` : "--client=<your-ai>";
+}
+function skillMarkdown(client) {
+  const cf = clientFlag(client);
+  return `---
+name: vg
+description: Query the local code graph (vg) for structure, impact, and navigation instead of grepping/reading many files.
+---
+
+${versionMarker()}
+
+# vg \u2014 the code map
+
+This repo has a deterministic code graph built by \`vg\`. Prefer it over reading or
+grepping many files \u2014 it is smaller, more relevant context, and free.
+
+## Use the MCP tools \u2014 not the CLI
+
+When the \`vg\` MCP server is registered (it is after \`vg install\`), **always call
+its read-only tools instead of shelling out to the CLI.** The server keeps the
+map parsed, the relation index warm, and the embedding model loaded across
+calls, so an MCP call answers in milliseconds \u2014 while every CLI invocation pays
+Node startup plus a fresh map parse, hundreds of times more. Tools:
+\`query_graph\`, \`get_node\`, \`impact_of\`, \`find_path\`, \`list_hubs\`, \`list_areas\`,
+\`get_graph_summary\`, \`search_symbols\`. They are side-effect-free and
+auto-approvable, and the server records which client is calling automatically.
+Reach for the CLI only when the MCP server is genuinely unavailable \u2014 never as
+the first resort.
+
+## CLI fallback \u2014 only when the MCP server is unavailable
+
+If (and only if) no \`vg\` MCP server is available, use the CLI \u2014 and **always
+pass \`${cf}\`** so your calls are counted (that's how the CLI-vs-MCP split is
+measured and the tools improved):
+
+- **Understand code:** \`vg "<question>" ${cf}\` \u2014 a budget-bounded, fact-annotated context block.
+- **Find a symbol:** \`vg show <name> ${cf}\` \u2014 what it is, what it calls, what calls it.
+- **Before changing something:** \`vg impact <name> ${cf}\` \u2014 what breaks if you change it.
+- **Navigate:** \`vg path <A> <B> ${cf}\`, \`vg tree <name> ${cf}\`.
+
+## Dependencies & library docs
+
+- **Upgrade drift:** \`vg drift\` lists what is outdated across dependencies
+  (offline; \`--online\` for currency). \`vg scan\` scores upgrade drift and
+  \`vg report\` renders it (text | json | sarif | md).
+- **Version-correct docs:** \`vg lib <name>\` returns drift-annotated, version-
+  specific usage docs for a library \u2014 inject these instead of guessing an API.
+
+### Library-docs discipline
+
+When a task needs a library's API, use the docs tools before web search or
+training-data recall \u2014 they are official content matched to the version **this
+project has installed**, and they win when the two conflict.
+
+- **Workflow:** \`resolve_library\` once per library, then \`library_docs\` with the
+  returned \`targetId\` and a focused query (good: "zod refine custom error
+  message"; bad: "zod"). Never guess a targetId.
+- **Budget:** at most **3 docs calls per task**. If 2 \`library_docs\` calls have
+  not surfaced the section you need, read the package source under
+  \`node_modules\` instead of searching again.
+- **Skip the docs tools** for language built-ins, stable well-known syntax, or
+  an API already shown in the current context \u2014 they add nothing there.
+
+## Keep it fresh
+
+The map keeps itself fresh: \`vg ask\` and the MCP tools detect changed files
+and rebuild it incrementally before answering \u2014 you can edit code and query
+immediately. Running \`vg\` after a large pull still warms everything in one go.
+The map lives at \`.vibgrate/graph.json\` and is deterministic (byte-identical
+across machines).
+`;
+}
+function nudgeMarkdown(smallRepo, client) {
+  const cf = clientFlag(client);
+  if (smallRepo) {
+    return `${NUDGE_BEGIN}
+${versionMarker()}
+## Code navigation (vg)
+
+This repo is small enough that searching files directly is fine. Still, before a
+change, the \`vg\` graph shows what breaks: use the \`vg\` MCP tools when the server
+is registered (\`impact_of\`, \`query_graph\` \u2014 the warm server answers far faster
+than spawning the CLI). Only without the server, fall back to the CLI and pass
+\`${cf}\` so the call is counted: \`vg impact <name> ${cf}\`,
+\`vg "<question>" ${cf}\`.
+${NUDGE_END}`;
+  }
+  return `${NUDGE_BEGIN}
+${versionMarker()}
+## Code navigation (vg) \u2014 use the MCP tools first
+
+A deterministic code graph is available. It is usually the faster, cheaper path
+than reading or grepping many files. **When the \`vg\` MCP server is registered,
+always use its tools** (\`query_graph\`, \`get_node\`, \`impact_of\`,
+\`search_symbols\`, \u2026) \u2014 the map, indexes, and embedding model stay warm across
+calls, so they answer in milliseconds, while every CLI invocation pays Node
+startup plus a fresh map parse. Fall back to the CLI only when the server is
+unavailable, and then pass \`${cf}\` so the call is counted:
+
+- \`vg "<question>" ${cf}\` \u2014 a compact, fact-annotated context block for a question.
+- \`vg show <name> ${cf}\` \u2014 what a symbol is, its callers and callees.
+- \`vg impact <name> ${cf}\` \u2014 what breaks if you change it.
+
+This is advisory, not mandatory \u2014 remove it with \`vg uninstall\` (or delete this
+block).
+${NUDGE_END}`;
+}
+function mcpServerEntry(launch = { command: "vg", args: ["serve"] }) {
+  return { command: launch.command, args: launch.args };
+}
+
+// src/install/registry.ts
+init_cli_invocation();
+var ASSISTANTS = [
+  {
+    id: "claude",
+    label: "Claude Code",
+    skill: ".claude/skills/vg/SKILL.md",
+    mcp: { file: ".mcp.json", key: "mcpServers" },
+    nudge: { file: "CLAUDE.md", kind: "block" },
+    markers: ["CLAUDE.md", ".claude"],
+    homeMarkers: [".claude", ".claude.json"],
+    bin: ["claude"]
+  },
+  {
+    id: "cursor",
+    label: "Cursor",
+    mcp: { file: ".cursor/mcp.json", key: "mcpServers" },
+    nudge: { file: ".cursor/rules/vg.mdc", kind: "file" },
+    markers: [".cursor", ".cursorrules"],
+    homeMarkers: [".cursor"],
+    bin: ["cursor-agent"]
+  },
+  {
+    id: "windsurf",
+    label: "Windsurf",
+    mcp: { file: ".windsurf/mcp.json", key: "mcpServers" },
+    nudge: { file: ".windsurf/rules/vg.md", kind: "file" },
+    markers: [".windsurf", ".windsurfrules"],
+    homeMarkers: [".codeium/windsurf"]
+  },
+  {
+    id: "vscode",
+    label: "VS Code (Copilot Chat)",
+    mcp: { file: ".vscode/mcp.json", key: "servers", vscode: true },
+    nudge: { file: ".github/copilot-instructions.md", kind: "block" },
+    markers: [".github/copilot-instructions.md"]
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    skill: ".codex/skills/vg/SKILL.md",
+    nudge: { file: "AGENTS.md", kind: "block" },
+    markers: [".codex"],
+    homeMarkers: [".codex"],
+    bin: ["codex"]
+  },
+  {
+    id: "gemini",
+    label: "Gemini CLI",
+    skill: ".gemini/skills/vg/SKILL.md",
+    nudge: { file: "GEMINI.md", kind: "block" },
+    markers: ["GEMINI.md", ".gemini"],
+    homeMarkers: [".gemini"],
+    bin: ["gemini"]
+  },
+  // Skill + advisory AGENTS.md nudge (the broad-reach common denominator). MCP
+  // registration for these hosts is host-specific and added as their formats
+  // stabilise; the skill + nudge work today.
+  { id: "grok", label: "Grok CLI", skill: ".grok/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".grok", "GROK.md"], homeMarkers: [".grok"], bin: ["grok"] },
+  { id: "opencode", label: "OpenCode", skill: ".opencode/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".opencode", "opencode.json"], homeMarkers: [".config/opencode"], bin: ["opencode"] },
+  { id: "kilo", label: "Kilo Code", skill: ".kilo/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".kilo", ".kilocode"], homeMarkers: [".kilocode"] },
+  { id: "aider", label: "Aider", skill: ".aider/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".aider", ".aider.conf.yml"], homeMarkers: [".aider.conf.yml"], bin: ["aider"] },
+  { id: "factory", label: "Factory Droid", skill: ".factory/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".factory"], homeMarkers: [".factory"], bin: ["droid"] },
+  { id: "trae", label: "Trae", skill: ".trae/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".trae"], homeMarkers: [".trae"] },
+  { id: "kiro", label: "Kiro", skill: ".kiro/skills/vg/SKILL.md", nudge: { file: ".kiro/steering/vg.md", kind: "file" }, markers: [".kiro"], homeMarkers: [".kiro"] },
+  { id: "amp", label: "Amp", skill: ".agents/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, homeMarkers: [".config/amp"], bin: ["amp"] },
+  { id: "kimi", label: "Kimi Code", skill: ".kimi/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".kimi"], homeMarkers: [".kimi"] },
+  { id: "codebuddy", label: "CodeBuddy", skill: ".codebuddy/skills/vg/SKILL.md", nudge: { file: "CODEBUDDY.md", kind: "block" }, markers: ["CODEBUDDY.md", ".codebuddy"], homeMarkers: [".codebuddy"] },
+  { id: "copilot-cli", label: "GitHub Copilot CLI", skill: ".copilot/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".copilot"], homeMarkers: [".copilot"], bin: ["copilot"] },
+  { id: "pi", label: "Pi", skill: ".pi/agent/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".pi"], homeMarkers: [".pi"] },
+  { id: "devin", label: "Devin CLI", skill: ".devin/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".devin"], homeMarkers: [".devin"] },
+  { id: "hermes", label: "Hermes", skill: ".hermes/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".hermes"], homeMarkers: [".hermes"] },
+  { id: "openclaw", label: "OpenClaw", skill: ".openclaw/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: [".openclaw"], homeMarkers: [".openclaw"], bin: ["openclaw"] },
+  { id: "agents", label: "Agent-Skills (generic)", skill: ".agents/skills/vg/SKILL.md", nudge: { file: "AGENTS.md", kind: "block" }, markers: ["AGENTS.md", ".agents"] }
+];
+function assistantById(id) {
+  return ASSISTANTS.find((a) => a.id === id);
+}
+function detectAssistants(root, opts = {}) {
+  const home = opts.home ?? os.homedir();
+  const which = opts.which ?? whichOnPath;
+  const found = [];
+  for (const assistant of ASSISTANTS) {
+    const repoHit = (assistant.markers ?? []).find((m) => fs10.existsSync(path10.join(root, m)));
+    if (repoHit) {
+      found.push({ assistant, via: "repo", marker: repoHit });
+      continue;
+    }
+    const homeHit = (assistant.homeMarkers ?? []).find((m) => fs10.existsSync(path10.join(home, m)));
+    if (homeHit) {
+      found.push({ assistant, via: "home", marker: homeHit });
+      continue;
+    }
+    const binHit = (assistant.bin ?? []).find((b) => which(b) !== null);
+    if (binHit) found.push({ assistant, via: "path", marker: binHit });
+  }
+  return found;
+}
+function detectServeLaunch(which = whichOnPath) {
+  const vg = which("vg");
+  if (vg && isInstalledOwnBinary(vg)) return { command: "vg", args: ["serve"] };
+  const vibgrate = which("vibgrate");
+  if (vibgrate && isInstalledOwnBinary(vibgrate)) {
+    return {
+      command: "vibgrate",
+      args: ["serve"],
+      note: vg ? "`vg` on PATH belongs to another tool \u2014 registered the identical `vibgrate serve` instead" : "`vg` is not on PATH \u2014 registered the identical `vibgrate serve` instead"
+    };
+  }
+  return {
+    command: "npx",
+    args: ["-y", "-p", "@vibgrate/cli", "vg", "serve"],
+    note: "vg is not installed on PATH \u2014 registered an npx launcher. Install globally (`npm i -g @vibgrate/cli`) and rerun `vg install` for a faster startup."
+  };
+}
+function installAssistant(a, opts) {
+  const wrote = [];
+  const skipped = [];
+  let note;
+  if (a.skill) {
+    writeFileEnsured(path10.join(opts.root, a.skill), skillMarkdown(a.id));
+    wrote.push(a.skill);
+  }
+  if (a.mcp) {
+    const launch = opts.launch ?? detectServeLaunch();
+    upsertMcp(path10.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(path10.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)");
+  }
+  return { wrote, skipped, note };
+}
+function uninstallAssistant(a, root, purge) {
+  const removed = [];
+  if (a.mcp) {
+    const file = path10.join(root, a.mcp.file);
+    if (removeMcp(file, a.mcp)) removed.push(a.mcp.file);
+  }
+  if (a.nudge) {
+    const file = path10.join(root, a.nudge.file);
+    if (a.nudge.kind === "block") {
+      if (removeBlock(file)) removed.push(a.nudge.file);
+    } else if (fs10.existsSync(file)) {
+      fs10.rmSync(file);
+      removed.push(a.nudge.file);
+    }
+  }
+  if (purge && a.skill) {
+    const file = path10.join(root, a.skill);
+    if (fs10.existsSync(file)) {
+      fs10.rmSync(file);
+      removed.push(a.skill);
+    }
+  }
+  return removed;
+}
+function writeFileEnsured(file, content) {
+  fs10.mkdirSync(path10.dirname(file), { recursive: true });
+  fs10.writeFileSync(file, content);
+}
+function writeNavigationConfig(root) {
+  ensureVibgrateGitignore(root);
+  const rel2 = path10.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(path10.join(root, rel2), `${JSON.stringify(doc, null, 2)}
+`);
+  return rel2;
+}
+function upsertMcp(file, target, launch) {
+  const config = readJson(file);
+  const entry = mcpServerEntry(launch);
+  const value = target.vscode ? { type: "stdio", ...entry } : entry;
+  const bag = config[target.key] && typeof config[target.key] === "object" ? config[target.key] : {};
+  bag.vg = value;
+  config[target.key] = bag;
+  writeFileEnsured(file, `${JSON.stringify(config, null, 2)}
+`);
+}
+function removeMcp(file, target) {
+  if (!fs10.existsSync(file)) return false;
+  const config = readJson(file);
+  const bag = config[target.key];
+  if (!bag || !(bag.vg !== void 0)) return false;
+  delete bag.vg;
+  writeFileEnsured(file, `${JSON.stringify(config, null, 2)}
+`);
+  return true;
+}
+var SMALL_REPO_FILES = 150;
+function refreshInstalledInstructions(root, smallRepo) {
+  const out = [];
+  const staleVersion = (text, legacySignature) => {
+    const v = installedContentVersion(text);
+    if (v !== null) return v < INSTALL_CONTENT_VERSION ? v : null;
+    return text.includes(legacySignature) ? 0 : null;
+  };
+  for (const a of ASSISTANTS) {
+    if (a.skill) {
+      const file = path10.join(root, a.skill);
+      if (fs10.existsSync(file)) {
+        const text = readTextSafe(file);
+        const from = text === null ? null : staleVersion(text, "# vg \u2014 the code map");
+        if (from !== null) {
+          writeFileEnsured(file, skillMarkdown(a.id));
+          out.push({ file: a.skill, from, to: INSTALL_CONTENT_VERSION });
+        }
+      }
+    }
+    if (a.nudge) {
+      const file = path10.join(root, a.nudge.file);
+      if (!fs10.existsSync(file)) continue;
+      const text = readTextSafe(file);
+      if (text === null) continue;
+      if (a.nudge.kind === "block") {
+        const block = new RegExp(`${escapeRe(NUDGE_BEGIN)}[\\s\\S]*?${escapeRe(NUDGE_END)}`).exec(text);
+        if (!block) continue;
+        const from = staleVersion(block[0], "## Code navigation (vg)");
+        if (from !== null) {
+          writeNudge(file, a.nudge, smallRepo, a.id);
+          out.push({ file: a.nudge.file, from, to: INSTALL_CONTENT_VERSION });
+        }
+      } else {
+        const from = staleVersion(text, "## Code navigation (vg)");
+        if (from !== null) {
+          writeNudge(file, a.nudge, smallRepo, a.id);
+          out.push({ file: a.nudge.file, from, to: INSTALL_CONTENT_VERSION });
+        }
+      }
+    }
+  }
+  return out;
+}
+function readTextSafe(file) {
+  try {
+    return fs10.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function writeNudge(file, target, smallRepo, client) {
+  if (target.kind === "file") {
+    const body = file.endsWith(".mdc") ? `---
+description: vg code graph
+alwaysApply: true
+---
+${stripMarkers(nudgeMarkdown(smallRepo, client))}` : stripMarkers(nudgeMarkdown(smallRepo, client));
+    writeFileEnsured(file, `${body}
+`);
+    return;
+  }
+  upsertBlock(file, nudgeMarkdown(smallRepo, client));
+}
+function upsertBlock(file, block) {
+  fs10.mkdirSync(path10.dirname(file), { recursive: true });
+  let existing = fs10.existsSync(file) ? fs10.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*$/, "")}
+
+${block}
+` : `${block}
+`;
+  fs10.writeFileSync(file, existing);
+}
+function removeBlock(file) {
+  if (!fs10.existsSync(file)) return false;
+  const existing = fs10.readFileSync(file, "utf8");
+  const re = new RegExp(`\\n*${escapeRe(NUDGE_BEGIN)}[\\s\\S]*?${escapeRe(NUDGE_END)}\\n*`);
+  if (!re.test(existing)) return false;
+  fs10.writeFileSync(file, existing.replace(re, "\n"));
+  return true;
+}
+function readJson(file) {
+  if (!fs10.existsSync(file)) return {};
+  try {
+    const parsed = JSON.parse(fs10.readFileSync(file, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    throw new Error("not a JSON object");
+  } catch {
+    throw new CliError(
+      `${file} exists but is not valid JSON \u2014 fix or remove it, then rerun. Refusing to overwrite it (that would lose your existing entries).`,
+      ExitCode.ERROR
+    );
+  }
+}
+function stripMarkers(s) {
+  return s.replace(NUDGE_BEGIN, "").replace(NUDGE_END, "").trim();
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var REFRESH_LOCK_STALE_MS = 10 * 60 * 1e3;
+function refreshLockPath(root) {
+  return path10.join(cacheDir(root), "refresh.lock");
+}
+async function refreshIfStale(root, opts = {}) {
+  const probe = probeFreshness(root);
+  if (!probe) return { status: "no-snapshot" };
+  if (!hasDrift(probe.drift)) return { status: "fresh" };
+  const lock = refreshLockPath(root);
+  if (!acquireLock(lock, REFRESH_LOCK_STALE_MS)) return { status: "locked" };
+  const start = process.hrtime.bigint();
+  try {
+    const { scope } = probe;
+    const result = await buildGraph({
+      root,
+      only: scope.only,
+      exclude: scope.exclude,
+      paths: scope.paths,
+      deep: scope.deep,
+      noGround: scope.noGround,
+      scip: scope.scip,
+      noScip: scope.noScip,
+      noTsc: scope.noTsc,
+      cluster: scope.cluster,
+      grammarsDir: scope.grammarsDir,
+      inline: opts.inline,
+      jobs: opts.jobs
+    });
+    const wrote = result.graph.provenance.corpusHash !== probe.corpusHash;
+    if (wrote) {
+      const dir = vibgrateDir(root);
+      writeArtifacts(result.graph, {
+        root,
+        graphPath: opts.graphPath,
+        report: fs10.existsSync(path10.join(dir, "GRAPH_REPORT.md")),
+        html: fs10.existsSync(path10.join(dir, "graph.html"))
+      });
+    }
+    writeSnapshot(root, result.graph.provenance.corpusHash, result.fileStats, scope);
+    const ms = Number((process.hrtime.bigint() - start) / 1000000n);
+    return {
+      status: "refreshed",
+      drift: probe.drift,
+      ms,
+      reparsed: result.reparsed,
+      totalFiles: result.totalFiles,
+      wrote
+    };
+  } catch (err) {
+    return { status: "error", message: err.message };
+  } finally {
+    releaseLock(lock);
+  }
+}
+
+export { ASSISTANTS, CliError, ExitCode, ResourceLimitError, SKIP_DIRS, SKIP_FILES, SMALL_REPO_FILES, UsageError, analyze, applyCoverage, assistantById, buildFacts, buildGraph, decodeScipIndex, detectAssistants, detectServeLaunch, discover, driftCount, epistemicBreakdown, groundGraph, hasDrift, installAssistant, loadCoverage, loadSnapshot, probeFreshness, refreshIfStale, refreshInstalledInstructions, resolveLimits, scipEdges, uninstallAssistant, usageError, verifyDeterminism, writeNavigationConfig, writeSnapshot };
+//# sourceMappingURL=chunk-WDJNUC6V.js.map
+//# sourceMappingURL=chunk-WDJNUC6V.js.map