@vibgrate/cli 2026.704.3 → 2026.708.1

package/dist/{chunk-JL7FIC6W.js → chunk-2J7DPIAL.js}

@@ -1,5 +1,5 @@
 import { hashString, langById, shortId, canonicalize, grammarSetVersion, hashBytes, langForExtension, setGrammarsOverride, parseSource } from './chunk-X5YT263H.js';
-import { writeTextFile, pathExists, readJsonFile, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-YN5OGRWU.js';
+import { writeTextFile, pathExists, readJsonFile, computeUpgradeImpact, getChangelogSignals, gitHistoryAvailable, buildVersionTimelines, findPackageTimeline, severityRank, projectTypeToVulnEcosystem, VERSION } from './chunk-SRWMZBLG.js';
 import * as fs18 from 'fs';
 import { execFileSync } from 'child_process';
 import * as path18 from 'path';
@@ -1624,6 +1624,7 @@ function resolve4(parses, resolver) {
     }
   }
   const edges = new EdgeSet();
+  const unresolved2 = /* @__PURE__ */ new Map();
   const stats = {
     callsResolved: 0,
     callsUnresolved: 0,
@@ -1672,6 +1673,7 @@ function resolve4(parses, resolver) {
         stats.callsResolved++;
       } else {
         stats.callsUnresolved++;
+        bumpUnresolved(unresolved2, srcId, call.callee, "call", p.rel);
       }
     }
   }
@@ -1683,6 +1685,7 @@ function resolve4(parses, resolver) {
       if (!srcId) continue;
       const target = resolveType(h.superName, p.rel, p.lang, imported, defsByName);
       if (target) edges.add(h.kind, srcId, target.id, "heuristic", 0.85);
+      else bumpUnresolved(unresolved2, srcId, h.superName, h.kind, p.rel);
     }
   }
   const nodes = [...baseNodes.values()].map((n) => ({
@@ -1693,7 +1696,16 @@ function resolve4(parses, resolver) {
     isHub: false,
     tested: null
   }));
-  return { nodes, edges: edges.toArray(), stats };
+  const unresolvedList = [...unresolved2.values()].sort(
+    (a, b) => a.from.localeCompare(b.from) || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)
+  );
+  return { nodes, edges: edges.toArray(), unresolved: unresolvedList, stats };
+}
+function bumpUnresolved(map, from, name, kind, fromRel) {
+  const key = `${from}\0${kind}\0${name}`;
+  const existing = map.get(key);
+  if (existing) existing.count++;
+  else map.set(key, { from, name, kind, count: 1, fromRel });
 }
 function addNode(map, n) {
   if (!map.has(n.id)) map.set(n.id, n);
@@ -2036,6 +2048,30 @@ function loadCache(root, opts) {
   };
 }
 
+// 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;
+}
+
 // src/engine/build.ts
 async function buildGraph(options) {
   const start = nowMs();
@@ -2117,6 +2153,7 @@ async function buildGraph(options) {
   const nodeFileById = new Map(resolved.nodes.map((n) => [n.id, n.file]));
   let edges = resolved.edges;
   const resolvers = [...resolved.stats.resolvers];
+  const preciseCoveredFiles = /* @__PURE__ */ new Set();
   let tscStats;
   let tsFiles = options.noTsc ? [] : files.filter((f) => (f.lang.id === "ts" || f.lang.id === "tsx" || f.lang.id === "js") && hashes.has(f.rel)).map((f) => ({ rel: f.rel, abs: f.abs }));
   if (limits.tscMaxFiles > 0 && tsFiles.length > limits.tscMaxFiles) {
@@ -2129,6 +2166,7 @@ async function buildGraph(options) {
     const res = tsResolveEdges(root, tsFiles, resolved.nodes);
     if (res.stats.files > 0) {
       edges = mergePreciseEdges(edges, res.edges, res.coveredFiles, nodeFileById);
+      for (const f of res.coveredFiles) preciseCoveredFiles.add(f);
       if (!resolvers.includes("tsc")) resolvers.unshift("tsc");
       tscStats = res.stats;
     }
@@ -2139,6 +2177,7 @@ async function buildGraph(options) {
   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 };
   }
@@ -2151,6 +2190,11 @@ async function buildGraph(options) {
   const languages = [...new Set(parses.map((p) => p.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(
@@ -2165,7 +2209,8 @@ async function buildGraph(options) {
       grammars: Object.fromEntries(languages.map((l) => [l, grammars])),
       resolver: resolvers,
       deep: options.deep ?? false,
-      corpusHash
+      corpusHash,
+      toolchain
     },
     meta: {
       root: path18.basename(root) === "" ? "." : ".",
@@ -2184,6 +2229,9 @@ async function buildGraph(options) {
     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;
   if (options.deep) {
     const facts = buildFacts(parses, analysis.nodes, analysis.edges);
     if (facts.length) graph.facts = facts;
@@ -2242,6 +2290,23 @@ function mergePreciseEdges(base, precise, coveredFiles, nodeFileById) {
     (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 list = parses.map((p) => [p.rel, hashes.get(p.rel) ?? p.hash]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
   return hashString(canonicalize(list));
@@ -2249,6 +2314,224 @@ function computeCorpusHash(parses, hashes) {
 function nowMs() {
   return Number(process.hrtime.bigint() / 1000n) / 1e3;
 }
+
+// src/engine/report.ts
+function renderReport(graph) {
+  const { meta, provenance, nodes, edges } = graph;
+  const lines = [];
+  lines.push("# Code Graph Report");
+  lines.push("");
+  lines.push(`Generated by \`vg\` ${provenance.version} \xB7 schema \`${graph.schemaVersion}\``);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- **Nodes:** ${meta.counts.nodes.toLocaleString("en-US")}`);
+  lines.push(`- **Edges:** ${meta.counts.edges.toLocaleString("en-US")}`);
+  lines.push(`- **Areas:** ${meta.counts.areas.toLocaleString("en-US")}`);
+  lines.push(`- **Languages:** ${meta.languages.join(", ") || "\u2014"}`);
+  lines.push(`- **Clustering:** ${meta.cluster}`);
+  lines.push(`- **Resolvers:** ${provenance.resolver.join(", ")}`);
+  lines.push(`- **Edge kinds:** ${meta.edgeKinds.join(", ") || "\u2014"}`);
+  lines.push("");
+  const fileNodes = nodes.filter((n) => n.kind === "file");
+  const defsByFile = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    defsByFile.set(n.file, (defsByFile.get(n.file) ?? 0) + 1);
+  }
+  const topFiles = [...defsByFile.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 15);
+  if (topFiles.length) {
+    lines.push("## Largest files (by definitions)");
+    lines.push("");
+    lines.push("| File | Definitions |");
+    lines.push("| --- | ---: |");
+    for (const [file, count] of topFiles) lines.push(`| \`${file}\` | ${count} |`);
+    lines.push("");
+  }
+  const topNodes = nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 15);
+  if (topNodes.length) {
+    lines.push("## Most-connected definitions");
+    lines.push("");
+    lines.push("| Symbol | Kind | File | Importance |");
+    lines.push("| --- | --- | --- | ---: |");
+    for (const n of topNodes) {
+      lines.push(
+        `| \`${n.qualifiedName}\` | ${n.kind} | \`${n.file}\`:${n.span.start} | ${n.importance.toFixed(3)} |`
+      );
+    }
+    lines.push("");
+  }
+  const byKind = /* @__PURE__ */ new Map();
+  for (const e of edges) byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + 1);
+  if (byKind.size) {
+    lines.push("## Edges by kind");
+    lines.push("");
+    lines.push("| Kind | Count |");
+    lines.push("| --- | ---: |");
+    for (const [kind, count] of [...byKind.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+      lines.push(`| ${kind} | ${count} |`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(`_Files: ${fileNodes.length} \xB7 Corpus: \`${provenance.corpusHash.slice(0, 16)}\u2026\`_`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/engine/html.ts
+function renderHtml(graph) {
+  const top = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 50);
+  const rows = top.map(
+    (n) => `<tr><td><code>${esc(n.qualifiedName)}</code></td><td>${esc(n.kind)}</td><td><code>${esc(n.file)}</code>:${n.span.start}</td><td>${n.importance.toFixed(3)}</td></tr>`
+  ).join("\n");
+  const embedded = stableStringify(graph, 0);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>vg \xB7 code graph</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font: 14px/1.5 system-ui, sans-serif; margin: 2rem auto; max-width: 60rem; padding: 0 1rem; }
+  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
+  table { border-collapse: collapse; width: 100%; }
+  th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #8884; }
+  td:last-child, th:last-child { text-align: right; }
+  .meta { color: #888; } code { font-size: 0.9em; }
+</style>
+</head>
+<body>
+<h1>vg \xB7 code graph</h1>
+<p class="meta">${graph.meta.counts.nodes} nodes \xB7 ${graph.meta.counts.edges} edges \xB7
+${graph.meta.counts.areas} areas \xB7 ${esc(graph.meta.languages.join(", ") || "\u2014")} \xB7
+clustering: ${esc(graph.meta.cluster)} \xB7 vg ${esc(graph.provenance.version)}</p>
+<h2>Most-connected definitions</h2>
+<table>
+<thead><tr><th>Symbol</th><th>Kind</th><th>Location</th><th>Importance</th></tr></thead>
+<tbody>
+${rows}
+</tbody>
+</table>
+<p class="meta">Interactive WebGL view arrives in Phase 1. The full graph is embedded below for tooling.</p>
+<script type="application/json" id="vg-graph">
+${embedded}
+</script>
+</body>
+</html>
+`;
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function vibgrateDir(root) {
+  return path18.join(root, ".vibgrate");
+}
+function defaultGraphPath(root) {
+  return path18.join(vibgrateDir(root), "graph.json");
+}
+function writeArtifacts(graph, options) {
+  const dir = vibgrateDir(options.root);
+  fs18.mkdirSync(dir, { recursive: true });
+  const graphPath = options.graphPath ?? defaultGraphPath(options.root);
+  fs18.mkdirSync(path18.dirname(graphPath), { recursive: true });
+  const tmp = `${graphPath}.${process.pid}.tmp`;
+  try {
+    fs18.writeFileSync(tmp, serializeGraph(graph));
+    fs18.renameSync(tmp, graphPath);
+  } catch (err) {
+    fs18.rmSync(tmp, { force: true });
+    throw err;
+  }
+  const written = { graphPath };
+  if (options.report !== false) {
+    const reportPath = path18.join(dir, "GRAPH_REPORT.md");
+    fs18.writeFileSync(reportPath, renderReport(graph));
+    written.reportPath = reportPath;
+  }
+  if (options.html !== false) {
+    const htmlPath = path18.join(dir, "graph.html");
+    fs18.writeFileSync(htmlPath, renderHtml(graph));
+    written.htmlPath = htmlPath;
+  }
+  if (graph.facts && graph.facts.length) {
+    const factsPath = path18.join(dir, "facts.jsonl");
+    fs18.writeFileSync(factsPath, graph.facts.map((f) => JSON.stringify(f)).join("\n") + "\n");
+    written.factsPath = factsPath;
+  }
+  return written;
+}
+function loadGraph(root, graphPath) {
+  const file = graphPath ?? defaultGraphPath(root);
+  if (!fs18.existsSync(file)) return null;
+  return parseGraph(fs18.readFileSync(file, "utf8"));
+}
+
+// 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 cached2 = 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 === cached2, detail: diffHint(a, cached2) }
+  ];
+  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 DEFAULT_LOCK_STALE_MS = 15 * 60 * 1e3;
 function isProcessAlive(pid) {
   try {
@@ -2574,155 +2857,6 @@ async function getNodeEmbeddings(graph, embedder, root, onProgress) {
 function safe(id) {
   return id.replace(/[^a-z0-9.-]+/gi, "_");
 }
-
-// src/engine/report.ts
-function renderReport(graph) {
-  const { meta, provenance, nodes, edges } = graph;
-  const lines = [];
-  lines.push("# Code Graph Report");
-  lines.push("");
-  lines.push(`Generated by \`vg\` ${provenance.version} \xB7 schema \`${graph.schemaVersion}\``);
-  lines.push("");
-  lines.push("## Summary");
-  lines.push("");
-  lines.push(`- **Nodes:** ${meta.counts.nodes.toLocaleString("en-US")}`);
-  lines.push(`- **Edges:** ${meta.counts.edges.toLocaleString("en-US")}`);
-  lines.push(`- **Areas:** ${meta.counts.areas.toLocaleString("en-US")}`);
-  lines.push(`- **Languages:** ${meta.languages.join(", ") || "\u2014"}`);
-  lines.push(`- **Clustering:** ${meta.cluster}`);
-  lines.push(`- **Resolvers:** ${provenance.resolver.join(", ")}`);
-  lines.push(`- **Edge kinds:** ${meta.edgeKinds.join(", ") || "\u2014"}`);
-  lines.push("");
-  const fileNodes = nodes.filter((n) => n.kind === "file");
-  const defsByFile = /* @__PURE__ */ new Map();
-  for (const n of nodes) {
-    if (n.kind === "file" || n.kind === "external") continue;
-    defsByFile.set(n.file, (defsByFile.get(n.file) ?? 0) + 1);
-  }
-  const topFiles = [...defsByFile.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 15);
-  if (topFiles.length) {
-    lines.push("## Largest files (by definitions)");
-    lines.push("");
-    lines.push("| File | Definitions |");
-    lines.push("| --- | ---: |");
-    for (const [file, count] of topFiles) lines.push(`| \`${file}\` | ${count} |`);
-    lines.push("");
-  }
-  const topNodes = nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 15);
-  if (topNodes.length) {
-    lines.push("## Most-connected definitions");
-    lines.push("");
-    lines.push("| Symbol | Kind | File | Importance |");
-    lines.push("| --- | --- | --- | ---: |");
-    for (const n of topNodes) {
-      lines.push(
-        `| \`${n.qualifiedName}\` | ${n.kind} | \`${n.file}\`:${n.span.start} | ${n.importance.toFixed(3)} |`
-      );
-    }
-    lines.push("");
-  }
-  const byKind = /* @__PURE__ */ new Map();
-  for (const e of edges) byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + 1);
-  if (byKind.size) {
-    lines.push("## Edges by kind");
-    lines.push("");
-    lines.push("| Kind | Count |");
-    lines.push("| --- | ---: |");
-    for (const [kind, count] of [...byKind.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-      lines.push(`| ${kind} | ${count} |`);
-    }
-    lines.push("");
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push(`_Files: ${fileNodes.length} \xB7 Corpus: \`${provenance.corpusHash.slice(0, 16)}\u2026\`_`);
-  lines.push("");
-  return lines.join("\n");
-}
-
-// src/engine/html.ts
-function renderHtml(graph) {
-  const top = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external").sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)).slice(0, 50);
-  const rows = top.map(
-    (n) => `<tr><td><code>${esc(n.qualifiedName)}</code></td><td>${esc(n.kind)}</td><td><code>${esc(n.file)}</code>:${n.span.start}</td><td>${n.importance.toFixed(3)}</td></tr>`
-  ).join("\n");
-  const embedded = stableStringify(graph, 0);
-  return `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>vg \xB7 code graph</title>
-<style>
-  :root { color-scheme: light dark; }
-  body { font: 14px/1.5 system-ui, sans-serif; margin: 2rem auto; max-width: 60rem; padding: 0 1rem; }
-  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
-  table { border-collapse: collapse; width: 100%; }
-  th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #8884; }
-  td:last-child, th:last-child { text-align: right; }
-  .meta { color: #888; } code { font-size: 0.9em; }
-</style>
-</head>
-<body>
-<h1>vg \xB7 code graph</h1>
-<p class="meta">${graph.meta.counts.nodes} nodes \xB7 ${graph.meta.counts.edges} edges \xB7
-${graph.meta.counts.areas} areas \xB7 ${esc(graph.meta.languages.join(", ") || "\u2014")} \xB7
-clustering: ${esc(graph.meta.cluster)} \xB7 vg ${esc(graph.provenance.version)}</p>
-<h2>Most-connected definitions</h2>
-<table>
-<thead><tr><th>Symbol</th><th>Kind</th><th>Location</th><th>Importance</th></tr></thead>
-<tbody>
-${rows}
-</tbody>
-</table>
-<p class="meta">Interactive WebGL view arrives in Phase 1. The full graph is embedded below for tooling.</p>
-<script type="application/json" id="vg-graph">
-${embedded}
-</script>
-</body>
-</html>
-`;
-}
-function esc(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function vibgrateDir(root) {
-  return path18.join(root, ".vibgrate");
-}
-function defaultGraphPath(root) {
-  return path18.join(vibgrateDir(root), "graph.json");
-}
-function writeArtifacts(graph, options) {
-  const dir = vibgrateDir(options.root);
-  fs18.mkdirSync(dir, { recursive: true });
-  const graphPath = options.graphPath ?? defaultGraphPath(options.root);
-  fs18.mkdirSync(path18.dirname(graphPath), { recursive: true });
-  const tmp = `${graphPath}.${process.pid}.tmp`;
-  try {
-    fs18.writeFileSync(tmp, serializeGraph(graph));
-    fs18.renameSync(tmp, graphPath);
-  } catch (err) {
-    fs18.rmSync(tmp, { force: true });
-    throw err;
-  }
-  const written = { graphPath };
-  if (options.report !== false) {
-    const reportPath = path18.join(dir, "GRAPH_REPORT.md");
-    fs18.writeFileSync(reportPath, renderReport(graph));
-    written.reportPath = reportPath;
-  }
-  if (options.html !== false) {
-    const htmlPath = path18.join(dir, "graph.html");
-    fs18.writeFileSync(htmlPath, renderHtml(graph));
-    written.htmlPath = htmlPath;
-  }
-  if (graph.facts && graph.facts.length) {
-    const factsPath = path18.join(dir, "facts.jsonl");
-    fs18.writeFileSync(factsPath, graph.facts.map((f) => JSON.stringify(f)).join("\n") + "\n");
-    written.factsPath = factsPath;
-  }
-  return written;
-}
 var SNAPSHOT_VERSION = "vg-freshness/1";
 function snapshotPath(root) {
   return path18.join(cacheDir(root), "freshness.json");
@@ -2824,62 +2958,6 @@ function pruneScope(scope) {
   return out;
 }
 
-// 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);
-}
-function loadGraph(root, graphPath) {
-  const file = graphPath ?? defaultGraphPath(root);
-  if (!fs18.existsSync(file)) return null;
-  return parseGraph(fs18.readFileSync(file, "utf8"));
-}
-
-// 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 a = serializeGraph((await buildGraph({ ...base, noCache: true, jobs: opts.jobs })).graph);
-  const b = serializeGraph((await buildGraph({ ...base, noCache: true, jobs: 1 })).graph);
-  const cached2 = 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 === cached2, detail: diffHint(a, cached2) }
-  ];
-  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/engine/relations.ts
 var GraphIndex = class {
   constructor(graph) {
@@ -5537,6 +5615,17 @@ var obj = (properties, required = []) => ({
 var RESPONSE_FORMAT = { type: "string", enum: ["concise", "detailed"] };
 var isDetailed = (args) => args.response_format === "detailed";
 var CONCISE_MATCHES = 5;
+var EPISTEMIC_TIERS = ["observed", "name-matched", "declared"];
+var EDGE_FILTER_SCHEMA = {
+  min_edge_confidence: { type: "number", description: "0..1 \u2014 drop edges below this confidence" },
+  epistemic: { type: "string", enum: EPISTEMIC_TIERS, description: "keep only edges of this evidence tier" }
+};
+function edgeRecordFilter(args) {
+  const min = numOrU(args.min_edge_confidence);
+  const tier = EPISTEMIC_TIERS.includes(String(args.epistemic)) ? String(args.epistemic) : void 0;
+  if (min == null && !tier) return () => true;
+  return (x) => (min == null || x.edge.confidence >= min) && (!tier || x.edge.epistemic === tier);
+}
 var TOOLS = [
   {
     name: "orient",
@@ -5639,6 +5728,7 @@ var TOOLS = [
       {
         name: { type: "string" },
         pick: { type: "number", description: "nth candidate if ambiguous" },
+        ...EDGE_FILTER_SCHEMA,
         response_format: RESPONSE_FORMAT
       },
       ["name"]
@@ -5647,6 +5737,9 @@ var TOOLS = [
       const { node, candidates } = resolveOne(graph, String(args.name ?? ""), numOrU(args.pick));
       if (!node) return unresolved(candidates);
       const index = new GraphIndex(graph);
+      const edgeOk = edgeRecordFilter(args);
+      const calleeRecs = index.callees(node.id).filter(edgeOk);
+      const callerRecs = index.callers(node.id).filter(edgeOk);
       const base = {
         name: node.qualifiedName,
         kind: node.kind,
@@ -5658,11 +5751,11 @@ var TOOLS = [
         area: node.area
       };
       if (ctx?.dedup && ctx.seen?.has(node.id)) {
-        return { ...base, repeat: true, callsTotal: uniqueNames(index.callees(node.id).map((x) => x.node.qualifiedName)).length, calledByTotal: uniqueNames(index.callers(node.id).map((x) => x.node.qualifiedName)).length };
+        return { ...base, repeat: true, callsTotal: uniqueNames(calleeRecs.map((x) => x.node.qualifiedName)).length, calledByTotal: uniqueNames(callerRecs.map((x) => x.node.qualifiedName)).length };
       }
       const edgeCap = isDetailed(args) ? NODE_EDGE_CAP : CONCISE_MATCHES;
-      const calls = boundList(uniqueNames(index.callees(node.id).map((x) => x.node.qualifiedName)), edgeCap);
-      const calledBy = boundList(uniqueNames(index.callers(node.id).map((x) => x.node.qualifiedName)), edgeCap);
+      const calls = boundList(uniqueNames(calleeRecs.map((x) => x.node.qualifiedName)), edgeCap);
+      const calledBy = boundList(uniqueNames(callerRecs.map((x) => x.node.qualifiedName)), edgeCap);
       ctx?.seen?.add(node.id);
       return {
         ...base,
@@ -5705,6 +5798,7 @@ var TOOLS = [
         change_type: { type: "string", enum: ["modify", "delete", "rename", "add_dependency"] },
         depth: { type: "number", description: "default 4" },
         pick: { type: "number", description: "nth candidate if ambiguous" },
+        min_edge_confidence: { type: "number", description: "0..1 \u2014 drop dependents below this (decayed) confidence" },
         response_format: RESPONSE_FORMAT
       },
       ["name"]
@@ -5714,6 +5808,14 @@ var TOOLS = [
       if (!node) return unresolved(candidates);
       const changeType = ["modify", "delete", "rename", "add_dependency"].includes(String(args.change_type)) ? String(args.change_type) : "modify";
       const r = impactOf(graph, node.id, { depth: numOr(args.depth, 4) });
+      const minConf = numOrU(args.min_edge_confidence);
+      if (minConf != null) {
+        const kept = r.affected.filter((a) => a.confidence >= minConf);
+        r.affected = kept;
+        r.direct = kept.filter((i) => i.depth === 1).length;
+        r.transitive = kept.filter((i) => i.depth > 1).length;
+        r.minEdgeConfidence = kept.length ? Math.min(...kept.map((i) => i.confidence)) : 1;
+      }
       const tests = coveringTests(graph, node);
       const filesAffected = [...new Set(r.affected.map((a) => a.file))];
       const heavyChange = changeType === "delete" || changeType === "rename";
@@ -6610,6 +6712,8 @@ function formatForExt(ext) {
       return "dot";
     case ".cypher":
       return "cypher";
+    case ".sql":
+      return "sql";
     case ".md":
       return "md";
     case ".html":
@@ -6634,6 +6738,8 @@ function exportGraph(format, ctx) {
       return dot(ctx.graph);
     case "cypher":
       return cypher(ctx.graph);
+    case "sql":
+      return sql(ctx);
     case "cyclonedx":
       return cyclonedx(ctx);
     case "spdx":
@@ -6696,6 +6802,66 @@ function cypherLabel(s) {
 function q(s) {
   return JSON.stringify(s);
 }
+function sql(ctx) {
+  const graph = ctx.graph;
+  const lines = [];
+  lines.push("BEGIN;");
+  lines.push("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);");
+  const meta = [
+    ["schemaVersion", graph.schemaVersion],
+    ["generatedAt", ctx.generatedAt],
+    ["corpusHash", graph.provenance.corpusHash],
+    ["tool", graph.provenance.tool],
+    ["toolVersion", graph.provenance.version],
+    ["resolver", graph.provenance.resolver.join(",")],
+    ["fingerprint", graph.provenance.toolchain?.fingerprint ?? null]
+  ];
+  for (const [k, v] of meta) lines.push(`INSERT INTO meta VALUES (${sqlStr(k)}, ${sqlStr(v)});`);
+  lines.push(
+    "CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, kind TEXT, name TEXT, qualified_name TEXT, file TEXT, span_start INTEGER, span_end INTEGER, lang TEXT, visibility TEXT, signature TEXT, importance REAL, area INTEGER, is_hub INTEGER, tested INTEGER, coverage REAL);"
+  );
+  for (const n of graph.nodes) {
+    lines.push(
+      `INSERT INTO nodes VALUES (${sqlStr(n.id)}, ${sqlStr(n.kind)}, ${sqlStr(n.name)}, ${sqlStr(n.qualifiedName)}, ${sqlStr(n.file)}, ${sqlNum(n.span.start)}, ${sqlNum(n.span.end)}, ${sqlStr(n.lang)}, ${sqlStr(n.visibility)}, ${sqlStr(n.signature)}, ${sqlNum(n.importance)}, ${sqlNum(n.area)}, ${sqlBool(n.isHub)}, ${sqlBool(n.tested)}, ${sqlNum(n.coverage)});`
+    );
+  }
+  lines.push(
+    'CREATE TABLE IF NOT EXISTS edges (id TEXT PRIMARY KEY, kind TEXT, src TEXT, dst TEXT, resolution TEXT, confidence REAL, epistemic TEXT, surprise REAL, "count" INTEGER);'
+  );
+  for (const e of graph.edges) {
+    lines.push(
+      `INSERT INTO edges VALUES (${sqlStr(e.id)}, ${sqlStr(e.kind)}, ${sqlStr(e.src)}, ${sqlStr(e.dst)}, ${sqlStr(e.resolution)}, ${sqlNum(e.confidence)}, ${sqlStr(e.epistemic)}, ${sqlNum(e.surprise)}, ${sqlNum(e.count)});`
+    );
+  }
+  lines.push("CREATE TABLE IF NOT EXISTS areas (id INTEGER PRIMARY KEY, label TEXT, size INTEGER, cohesion REAL, external_edges INTEGER);");
+  lines.push("CREATE TABLE IF NOT EXISTS area_members (area_id INTEGER, node_id TEXT);");
+  for (const a of graph.areas) {
+    lines.push(`INSERT INTO areas VALUES (${sqlNum(a.id)}, ${sqlStr(a.label)}, ${sqlNum(a.size)}, ${sqlNum(a.cohesion)}, ${sqlNum(a.externalEdges)});`);
+    for (const m of a.members) lines.push(`INSERT INTO area_members VALUES (${sqlNum(a.id)}, ${sqlStr(m)});`);
+  }
+  if (graph.facts && graph.facts.length) {
+    lines.push("CREATE TABLE IF NOT EXISTS facts (id TEXT PRIMARY KEY, kind TEXT, predicate_json TEXT, derived_by TEXT, confidence TEXT);");
+    lines.push("CREATE TABLE IF NOT EXISTS fact_subjects (fact_id TEXT, node_id TEXT);");
+    lines.push("CREATE TABLE IF NOT EXISTS fact_evidence (fact_id TEXT, file TEXT, span_start INTEGER, span_end INTEGER);");
+    for (const f of graph.facts) {
+      lines.push(`INSERT INTO facts VALUES (${sqlStr(f.id)}, ${sqlStr(f.kind)}, ${sqlStr(JSON.stringify(f.predicate))}, ${sqlStr(f.derivedBy)}, ${sqlStr(f.confidence)});`);
+      for (const s of f.subjectIds) lines.push(`INSERT INTO fact_subjects VALUES (${sqlStr(f.id)}, ${sqlStr(s)});`);
+      for (const ev of f.evidence) lines.push(`INSERT INTO fact_evidence VALUES (${sqlStr(f.id)}, ${sqlStr(ev.file)}, ${sqlNum(ev.span.start)}, ${sqlNum(ev.span.end)});`);
+    }
+  }
+  lines.push("COMMIT;");
+  return lines.join("\n") + "\n";
+}
+function sqlStr(v) {
+  if (v == null) return "NULL";
+  return `'${v.replace(/'/g, "''")}'`;
+}
+function sqlNum(v) {
+  return v == null || !Number.isFinite(v) ? "NULL" : String(v);
+}
+function sqlBool(v) {
+  return v == null ? "NULL" : v ? "1" : "0";
+}
 function cyclonedx(ctx) {
   const components = [];
   for (const d of ctx.deps ?? []) {
@@ -6735,6 +6901,6 @@ function spdx(ctx) {
   return JSON.stringify(doc, null, 2) + "\n";
 }
 
-export { ASSISTANTS, CliError, ECOSYSTEMS, ExitCode, FREE_PACK, GraphIndex, GraphSource, NPX_INVOCATION, ResourceLimitError, SCHEMA_VERSION, SKIP_DIRS, SKIP_FILES, TOOLS, UsageError, addLibrary, analyze, applyCoverage, applyStaticTestLinkage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, buildModuleResolver, cacheDir, catalogPath, clearModelCache, clearStoredCredentials, cosine, countPending, coveringTests, createServer, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, defaultGraphPath, detectRunner, detectServeLaunch, discover, discoverModels, driftCount, driftFor, dsnCommand, embeddingsCached, enrichOnline, ensureGitignored, exportGraph, fetchHostedDocs, findGitRoot, findNodes, formatForExt, getNodeEmbeddings, gitignoreEntryForCredentials, groundGraph, hasDrift, identifierParts, impactOf, installAssistant, inventory, isModelReady, isTestFile, libDir, libId, loadCatalog, loadCoverage, loadEmbedder, loadGraph, loadSnapshot, localApiSurface, localPackageDocs, modelCacheInfo, nodeById, nodeEmbedText, parseDsn, parseGraph, parseJsonc, probeFreshness, publishPrivateLibrary, pushCommand, queryGraph, queryGraphSemantic, readDoc, readSavings, readScanArtifact, recordSaving, refreshIfStale, relativeResolver, renderHtml, renderReport, resolveCliInvocation, resolveDsn, resolveEmbedModel, resolveIngestHost, resolveLib, resolveLimits, resolveOne, resolveVersion, saveCatalog, savingsRecorded, scipEdges, selectForBudget, serializeGraph, serveStdio, shortestPath, stableStringify, symbolsFromApi, testsToRun, unavailableMessage, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, vibgrateDir, writeArtifacts, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
-//# sourceMappingURL=chunk-JL7FIC6W.js.map
-//# sourceMappingURL=chunk-JL7FIC6W.js.map
+export { ASSISTANTS, CliError, ECOSYSTEMS, ExitCode, FREE_PACK, GraphIndex, GraphSource, NPX_INVOCATION, ResourceLimitError, SCHEMA_VERSION, SKIP_DIRS, SKIP_FILES, TOOLS, UsageError, addLibrary, analyze, applyCoverage, applyStaticTestLinkage, assessDocQuality, assistantById, availableRegionIds, buildFacts, buildGraph, buildModuleResolver, cacheDir, catalogPath, clearModelCache, clearStoredCredentials, cosine, countPending, coveringTests, createServer, createWorkspaceDsn, credentialsPath, dashHostForIngestHost, decodeScipIndex, defaultGraphPath, detectRunner, detectServeLaunch, discover, discoverModels, driftCount, driftFor, dsnCommand, embeddingsCached, enrichOnline, ensureGitignored, epistemicBreakdown, exportGraph, fetchHostedDocs, findGitRoot, findNodes, formatForExt, getNodeEmbeddings, gitignoreEntryForCredentials, groundGraph, hasDrift, identifierParts, impactOf, ingestHostForRegionId, installAssistant, inventory, isModelReady, isTestFile, libDir, libId, loadCatalog, loadCoverage, loadEmbedder, loadGraph, loadSnapshot, localApiSurface, localPackageDocs, modelCacheInfo, nodeById, nodeEmbedText, parseDsn, parseGraph, parseJsonc, probeFreshness, publishPrivateLibrary, pushCommand, queryGraph, queryGraphSemantic, readDoc, readSavings, readScanArtifact, recordSaving, refreshIfStale, relativeResolver, renderHtml, renderReport, resolveCliInvocation, resolveDsn, resolveEmbedModel, resolveIngestHost, resolveLib, resolveLimits, resolveOne, resolveVersion, saveCatalog, savingsRecorded, scipEdges, selectForBudget, serializeGraph, serveStdio, shortestPath, stableStringify, symbolsFromApi, testsToRun, unavailableMessage, uninstallAssistant, uploadScanArtifact, usageError, verifyDeterminism, vibgrateDir, writeArtifacts, writeNavigationConfig, writeSnapshot, writeStoredCredentials };
+//# sourceMappingURL=chunk-2J7DPIAL.js.map
+//# sourceMappingURL=chunk-2J7DPIAL.js.map