@vibgrate/cli 2026.704.3 → 2026.708.2

package/dist/{chunk-JL7FIC6W.js → chunk-AWEAREOE.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-ICBBG6U3.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) {
@@ -2976,12 +3054,13 @@ function queryGraph(graph, question, options = {}) {
   const budget = options.budget ?? 2e3;
   const limit = options.limit ?? 12;
   const terms = tokenize(question);
+  const weightOf = termWeights(graph, terms);
   const index = new GraphIndex(graph);
   const scored = [];
   for (const node of graph.nodes) {
     if (node.kind === "file" || node.kind === "external") continue;
-    const { score, why } = scoreNode(node, terms);
-    if (score > 0) scored.push({ node, score: round2(score * (1 + node.importance)), why });
+    const { score, why } = scoreNode(node, terms, weightOf);
+    if (score > 0) scored.push({ node, score: round2(score * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
   }
   scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
   const seeds = scored.slice(0, limit);
@@ -2992,6 +3071,7 @@ async function queryGraphSemantic(graph, question, options) {
   const budget = options.budget ?? 2e3;
   const limit = options.limit ?? 12;
   const terms = tokenize(question);
+  const weightOf = termWeights(graph, terms);
   const index = new GraphIndex(graph);
   const queryVec = await options.embedder.embedQuery(question);
   const lexRaw = /* @__PURE__ */ new Map();
@@ -2999,7 +3079,7 @@ async function queryGraphSemantic(graph, question, options) {
   const whyById = /* @__PURE__ */ new Map();
   for (const node of graph.nodes) {
     if (node.kind === "file" || node.kind === "external") continue;
-    const { score, why } = scoreNode(node, terms);
+    const { score, why } = scoreNode(node, terms, weightOf);
     lexRaw.set(node.id, score);
     whyById.set(node.id, why);
     if (score > lexMax) lexMax = score;
@@ -3014,7 +3094,7 @@ async function queryGraphSemantic(graph, question, options) {
     if (hybrid <= 0) continue;
     const lexWhy = whyById.get(node.id);
     const why = lexWhy || (sem > 0.3 ? `semantic match (${sem.toFixed(2)})` : "weak match");
-    scored.push({ node, score: round2(hybrid * (1 + node.importance)), why });
+    scored.push({ node, score: round2(hybrid * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
   }
   scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
   const seeds = scored.slice(0, limit);
@@ -3028,7 +3108,7 @@ function tokenize(q2) {
     )
   ];
 }
-function scoreNode(node, terms) {
+function scoreNode(node, terms, weightOf = () => 1) {
   let score = 0;
   const hits = [];
   const name = node.name.toLowerCase();
@@ -3036,28 +3116,50 @@ function scoreNode(node, terms) {
   const file = node.file.toLowerCase();
   const nameParts = identifierParts(node.name);
   for (const t of terms) {
+    const w = weightOf(t);
     if (name === t) {
-      score += 10;
+      score += 10 * w;
       hits.push(t);
     } else if (nameParts.has(t)) {
-      score += 6;
+      score += 6 * w;
       hits.push(t);
     } else if (name.includes(t)) {
-      score += 4;
+      score += 4 * w;
       hits.push(t);
     } else if (qn.includes(t)) {
-      score += 3;
+      score += 3 * w;
       hits.push(t);
     } else if (fuzzyPartMatch(t, nameParts)) {
-      score += 2;
+      score += 2 * w;
       hits.push(`~${t}`);
     } else if (file.includes(t)) {
-      score += 1;
+      score += 1 * w;
       hits.push(t);
     }
   }
   return { score, why: hits.length ? `matched: ${hits.join(", ")}` : "" };
 }
+var IMPORTANCE_WEIGHT = 0.4;
+function termWeights(graph, terms) {
+  if (terms.length === 0) return () => 1;
+  const df = /* @__PURE__ */ new Map();
+  let n = 0;
+  for (const node of graph.nodes) {
+    if (node.kind === "file" || node.kind === "external") continue;
+    n++;
+    const name = node.name.toLowerCase();
+    const parts = identifierParts(node.name);
+    for (const t of terms) {
+      if (parts.has(t) || name.includes(t)) df.set(t, (df.get(t) ?? 0) + 1);
+    }
+  }
+  const w = /* @__PURE__ */ new Map();
+  for (const t of terms) {
+    const idf = Math.log((n + 1) / ((df.get(t) ?? 0) + 1)) + 1;
+    w.set(t, Math.max(0.5, Math.min(8, idf)));
+  }
+  return (t) => w.get(t) ?? 1;
+}
 function identifierParts(name) {
   return new Set(
     name.split(/[^a-zA-Z0-9]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/).filter(Boolean).map((s) => s.toLowerCase())
@@ -5416,7 +5518,11 @@ var PREVIEW_CHARS = 120;
 function searchSymbols(graph, root, query, limit) {
   const q2 = query.trim();
   if (!q2) return { matches: [], moreAvailable: false, hint: "query is required" };
-  const nodes = findNodes(graph, q2).filter((n) => n.kind !== "file");
+  let nodes = findNodes(graph, q2).filter((n) => n.kind !== "file");
+  if (nodes.length === 0) {
+    const tokens = queryTokens(q2);
+    if (tokens.length >= 2) nodes = multiTokenNodes(graph, tokens);
+  }
   const symbolHits = nodes.slice(0, limit).map((n, i) => ({
     kind: n.kind,
     name: n.qualifiedName,
@@ -5441,6 +5547,21 @@ function searchSymbols(graph, root, query, limit) {
   }
   return { matches, moreAvailable: nodes.length > symbolHits.length || truncatedScan };
 }
+function queryTokens(q2) {
+  return [...new Set(q2.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2))];
+}
+function multiTokenNodes(graph, tokens) {
+  const cov = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    for (const n of findNodes(graph, t)) {
+      if (n.kind === "file") continue;
+      const e = cov.get(n.id);
+      if (e) e.hits++;
+      else cov.set(n.id, { node: n, hits: 1 });
+    }
+  }
+  return [...cov.values()].sort((a, b) => b.hits - a.hits || b.node.importance - a.node.importance).map((e) => e.node);
+}
 function scanFiles(root, needle, budget, seen, out) {
   const lower = needle.toLowerCase();
   let scanned = 0;
@@ -5537,21 +5658,35 @@ 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",
     description: "Start here: one call returns the map overview, ranked matches for your question, and the top hit\u2019s blast radius \u2014 replaces summary+query+impact round-trips.",
-    inputSchema: obj(
-      {
-        question: { type: "string", maxLength: 300 },
-        scope: { type: "string", description: "path prefix to orient within" },
-        budget: { type: "number", description: "token budget in detailed mode (default 1500)" },
-        response_format: RESPONSE_FORMAT
-      },
-      ["question"]
-    ),
+    // `query` is a no-description back-compat alias for `question`: the sibling
+    // discovery tools (search_symbols, resolve_library) take `query`, so an agent
+    // naturally reaches for it here too — accepting it turns what was a wasted
+    // "question is required" round-trip into a hit. Neither is `required` (either
+    // satisfies the in-handler check), matching library_docs/resolve_library.
+    inputSchema: obj({
+      question: { type: "string", maxLength: 300 },
+      query: { type: "string", maxLength: 300 },
+      scope: { type: "string", description: "path prefix to orient within" },
+      budget: { type: "number", description: "token budget in detailed mode (default 1500)" },
+      response_format: RESPONSE_FORMAT
+    }),
     handler: async (graph, args, ctx) => {
-      const question = String(args.question ?? "");
+      const question = String(args.question ?? args.query ?? "");
       if (!question) return { error: "bad_request", message: "question is required" };
       const budget = numOr(args.budget, 1500);
       const { q: q2, mode } = await retrieve(graph, question, budget, ctx);
@@ -5567,7 +5702,11 @@ var TOOLS = [
       }
       const shown = detailed ? scoped : scoped.slice(0, CONCISE_MATCHES);
       return {
-        summary: summarize(graph, detailed ? 10 : CONCISE_MATCHES),
+        // Concise "find X" calls need a one-line map (counts + languages), not the
+        // full topAreas/topHubs blocks — those were ~half of every orient
+        // response's tokens on the hot discovery path and the caller navigates by
+        // `matches`. Detailed keeps the full overview.
+        summary: detailed ? summarize(graph, 10) : conciseSummary(graph),
         mode,
         // The fact-annotated context block is detail: concise callers navigate
         // by the ranked matches and fetch nodes on demand (plan P2).
@@ -5599,18 +5738,19 @@ var TOOLS = [
   {
     name: "query_graph",
     description: "Find code by meaning when you don\u2019t know the name: symptoms, relationships, what-breaks-if. For a known name or literal string use search_symbols.",
-    inputSchema: obj(
-      {
-        question: { type: "string", maxLength: 300 },
-        limit: { type: "number", description: "ranked matches to return (default 5)" },
-        offset: { type: "number" },
-        budget: { type: "number", description: "context-block token budget in detailed mode (default 2000)" },
-        response_format: RESPONSE_FORMAT
-      },
-      ["question"]
-    ),
+    // `query` is a no-description back-compat alias for `question` (see orient):
+    // sibling tools take `query`, so accept it here rather than reject the call.
+    inputSchema: obj({
+      question: { type: "string", maxLength: 300 },
+      query: { type: "string", maxLength: 300 },
+      limit: { type: "number", description: "ranked matches to return (default 5)" },
+      offset: { type: "number" },
+      budget: { type: "number", description: "context-block token budget in detailed mode (default 2000)" },
+      response_format: RESPONSE_FORMAT
+    }),
     handler: async (graph, args, ctx) => {
-      const question = String(args.question ?? "");
+      const question = String(args.question ?? args.query ?? "");
+      if (!question) return { mode: "lexical", matches: [], hint: "question (or query) is required" };
       const budget = numOr(args.budget, 2e3);
       const { q: r, mode } = await retrieve(graph, question, budget, ctx);
       if (r.matches.length === 0) {
@@ -5639,6 +5779,7 @@ var TOOLS = [
       {
         name: { type: "string" },
         pick: { type: "number", description: "nth candidate if ambiguous" },
+        ...EDGE_FILTER_SCHEMA,
         response_format: RESPONSE_FORMAT
       },
       ["name"]
@@ -5647,6 +5788,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 +5802,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 +5849,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 +5859,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";
@@ -6065,6 +6218,9 @@ var TOOLS = [
   }
 ];
 var VERBOSITY_BUDGET = { concise: 1500, balanced: 4e3, exhaustive: 12e3 };
+function conciseSummary(graph) {
+  return { counts: graph.meta.counts, languages: graph.meta.languages };
+}
 function summarize(graph, top = 10) {
   return {
     counts: graph.meta.counts,
@@ -6119,6 +6275,7 @@ function navigationToolsetConfig(serverName = "vibgrate") {
 }
 var LEDGER = "savings.jsonl";
 var PER_FILE_TOKENS = 400;
+var SAVINGS_TOOLS = /* @__PURE__ */ new Set(["query_graph", "get_node"]);
 function ledgerPath(root) {
   return path18.join(cacheDir(root), LEDGER);
 }
@@ -6147,6 +6304,7 @@ function readSavings(root, days, now, ratePerM = DEFAULT_RATE_PER_M) {
       try {
         const e = JSON.parse(line);
         if (e.ts < cutoff) continue;
+        if (!SAVINGS_TOOLS.has(e.tool)) continue;
         queries++;
         vgTokens += e.vgTokens;
         baselineTokens += e.baselineTokens;
@@ -6172,6 +6330,47 @@ function readSavings(root, days, now, ratePerM = DEFAULT_RATE_PER_M) {
 function round22(x) {
   return Math.round(x * 100) / 100;
 }
+function readUsage(root, days, now) {
+  const file = ledgerPath(root);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const byTool = /* @__PURE__ */ new Map();
+  if (fs18.existsSync(file)) {
+    for (const line of fs18.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.ts < cutoff) continue;
+        const outcome = e.outcome ?? "complete";
+        const row = byTool.get(e.tool) ?? { complete: 0, partial: 0, miss: 0 };
+        row[outcome]++;
+        byTool.set(e.tool, row);
+      } catch {
+      }
+    }
+  }
+  const commands = [...byTool.entries()].map(([tool, r]) => {
+    const calls = r.complete + r.partial + r.miss;
+    return {
+      tool,
+      calls,
+      complete: r.complete,
+      partial: r.partial,
+      miss: r.miss,
+      successPct: calls ? Math.round((r.complete + r.partial) / calls * 100) : 0
+    };
+  }).sort((a, b) => b.calls - a.calls || a.tool.localeCompare(b.tool));
+  const totals = commands.reduce(
+    (t, c) => ({
+      calls: t.calls + c.calls,
+      complete: t.complete + c.complete,
+      partial: t.partial + c.partial,
+      miss: t.miss + c.miss
+    }),
+    { calls: 0, complete: 0, partial: 0, miss: 0 }
+  );
+  const avgSuccessPct = commands.length ? Math.round(commands.reduce((s, c) => s + c.successPct, 0) / commands.length) : 0;
+  return { enabled: savingsRecorded(root), days, commands, totals, avgSuccessPct };
+}
 var PROBE_INTERVAL_MS = 2e3;
 var MAX_PROBE_INTERVAL_MS = 3e4;
 var PROBE_DUTY_FACTOR = 20;
@@ -6271,9 +6470,7 @@ function createServer(source, opts = {}) {
     try {
       const args = request.params.arguments ?? {};
       const result = await tool.handler(graph, args, { root, local, dedup, seen });
-      if (savings && (tool.name === "query_graph" || tool.name === "get_node")) {
-        maybeRecordSaving(root, tool.name, result);
-      }
+      if (savings) recordUsage(root, tool.name, result);
       return renderToolResult(result);
     } catch (err) {
       return errorResult(`tool "${tool.name}" failed: ${err.message}`);
@@ -6293,14 +6490,57 @@ function sleep(ms) {
     timer.unref?.();
   });
 }
-function maybeRecordSaving(root, tool, result) {
-  if (!result || typeof result !== "object") return;
+function recordUsage(root, tool, result) {
+  const outcome = classifyOutcome(result);
+  let vgTokens = 0;
+  let baselineTokens = 0;
+  if (SAVINGS_TOOLS.has(tool) && result && typeof result === "object") {
+    vgTokens = countTokens(renderedText(renderToolResult(result)));
+    baselineTokens = referencedFiles(result).size * PER_FILE_TOKENS;
+  }
+  recordSaving(root, { tool, outcome, vgTokens, baselineTokens }, Date.now());
+}
+function classifyOutcome(result) {
+  if (Array.isArray(result)) return result.length === 0 ? "miss" : "complete";
+  if (!result || typeof result !== "object") return "miss";
+  const r = result;
+  if (typeof r.error === "string" && r.error) return "miss";
+  if (r.connected === false) return "miss";
+  if (Array.isArray(r.matches) && r.matches.length === 0) return "miss";
+  return isPartial(r) ? "partial" : "complete";
+}
+function isPartial(r) {
+  if (r.moreAvailable === true) return true;
+  if (r._truncated && typeof r._truncated === "object") return true;
+  for (const [key, value] of Object.entries(r)) {
+    if (typeof value !== "number" || !key.endsWith("Total")) continue;
+    const base = key.slice(0, -"Total".length);
+    const shown = Array.isArray(r[base]) ? r[base].length : 0;
+    if (value > shown) return true;
+  }
+  return false;
+}
+function renderedText(rendered) {
+  const block = rendered.content?.find((b) => b.type === "text");
+  return block && "text" in block && typeof block.text === "string" ? block.text : "";
+}
+function referencedFiles(result) {
   const r = result;
-  const vgTokens = typeof r.tokensEstimate === "number" ? r.tokensEstimate : 0;
-  if (vgTokens <= 0) return;
-  const files = new Set((r.matches ?? []).map((m) => m.file).filter(Boolean));
-  const baselineTokens = files.size * PER_FILE_TOKENS;
-  recordSaving(root, { tool, vgTokens, baselineTokens }, Date.now());
+  const files = /* @__PURE__ */ new Set();
+  if (typeof r.file === "string" && r.file) files.add(r.file);
+  for (const m of asArray(r.matches)) {
+    const f = m.file;
+    if (typeof f === "string" && f) files.add(f);
+  }
+  for (const name of [...asArray(r.calls), ...asArray(r.calledBy)]) {
+    if (typeof name !== "string") continue;
+    const i = name.indexOf(":");
+    if (i > 0) files.add(name.slice(0, i));
+  }
+  return files;
+}
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
 }
 function errorResult(message) {
   return { content: [{ type: "text", text: message }], isError: true };
@@ -6610,6 +6850,8 @@ function formatForExt(ext) {
       return "dot";
     case ".cypher":
       return "cypher";
+    case ".sql":
+      return "sql";
     case ".md":
       return "md";
     case ".html":
@@ -6634,6 +6876,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 +6940,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 +7039,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, readUsage, 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-AWEAREOE.js.map
+//# sourceMappingURL=chunk-AWEAREOE.js.map