@neat.is/core 0.9.2-dev.20260822 → 0.9.3-dev.20260823

package/dist/server.cjs

@@ -787,7 +787,7 @@ function getGraph(project = DEFAULT_PROJECT) {
 init_cjs_shims();
 var import_fastify2 = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types92 = require("@neat.is/types");
+var import_types93 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -4160,11 +4160,11 @@ function actixAttributeRoute(attrItem, out) {
   if (!nameNode) return;
   const macro = nameNode.type === "identifier" ? nameNode.text : nameNode.type === "scoped_identifier" ? nameNode.childForFieldName("name")?.text ?? null : null;
   if (!macro) return;
-  const tokens = attr.childForFieldName("arguments");
-  if (!tokens || tokens.type !== "token_tree") return;
+  const tokens2 = attr.childForFieldName("arguments");
+  if (!tokens2 || tokens2.type !== "token_tree") return;
   const strings = [];
-  for (let i = 0; i < tokens.namedChildCount; i++) {
-    const s = rustStringContent(tokens.namedChild(i));
+  for (let i = 0; i < tokens2.namedChildCount; i++) {
+    const s = rustStringContent(tokens2.namedChild(i));
     if (s !== null) strings.push(s);
   }
   const pathStr = strings[0];
@@ -5982,29 +5982,29 @@ function promoteFrontierNodes(graph, opts = {}) {
     toPromote.push({ frontierId: id, serviceId: target });
   });
   let promoted = 0;
-  for (const { frontierId: frontierId2, serviceId: serviceId15 } of toPromote) {
+  for (const { frontierId: frontierId2, serviceId: serviceId16 } of toPromote) {
     if (opts.policies && opts.policies.length > 0 && opts.policyCtx) {
       const gate = canPromoteFrontier(graph, frontierId2, opts.policies, opts.policyCtx);
       if (!gate.allowed) {
         continue;
       }
     }
-    rewireFrontierEdges(graph, frontierId2, serviceId15);
+    rewireFrontierEdges(graph, frontierId2, serviceId16);
     graph.dropNode(frontierId2);
     promoted++;
   }
   return promoted;
 }
-function rewireFrontierEdges(graph, frontierId2, serviceId15) {
+function rewireFrontierEdges(graph, frontierId2, serviceId16) {
   const inbound = [...graph.inboundEdges(frontierId2)];
   const outbound = [...graph.outboundEdges(frontierId2)];
   for (const edgeId of inbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, edge.source, serviceId15, edgeId);
+    rebuildEdge(graph, edge, edge.source, serviceId16, edgeId);
   }
   for (const edgeId of outbound) {
     const edge = graph.getEdgeAttributes(edgeId);
-    rebuildEdge(graph, edge, serviceId15, edge.target, edgeId);
+    rebuildEdge(graph, edge, serviceId16, edge.target, edgeId);
   }
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
@@ -6350,7 +6350,7 @@ function databaseRootCauseShape(graph, origin, walk10) {
   for (const id of walk10.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId15, svc } = owner;
+    const { id: serviceId16, svc } = owner;
     const deps = svc.dependencies ?? {};
     for (const pair of candidatePairs) {
       const declared = deps[pair.driver];
@@ -6363,7 +6363,7 @@ function databaseRootCauseShape(graph, origin, walk10) {
       );
       if (!result.compatible) {
         return {
-          rootCauseNode: serviceId15,
+          rootCauseNode: serviceId16,
           rootCauseReason: result.reason ?? "incompatible driver",
           ...result.minDriverVersion ? {
             fixRecommendation: `Upgrade ${svc.name} ${pair.driver} driver to >= ${result.minDriverVersion}`
@@ -6378,7 +6378,7 @@ function serviceRootCauseShape(graph, _origin, walk10) {
   for (const id of walk10.path) {
     const owner = resolveOwningService(graph, id);
     if (!owner) continue;
-    const { id: serviceId15, svc } = owner;
+    const { id: serviceId16, svc } = owner;
     const deps = svc.dependencies ?? {};
     const serviceNodeEngine = svc.nodeEngine;
     for (const constraint of nodeEngineConstraints()) {
@@ -6387,7 +6387,7 @@ function serviceRootCauseShape(graph, _origin, walk10) {
       const result = checkNodeEngineConstraint(constraint, declared, serviceNodeEngine);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId15,
+          rootCauseNode: serviceId16,
           rootCauseReason: result.reason,
           ...result.requiredNodeVersion ? {
             fixRecommendation: `Bump ${svc.name}'s engines.node to >= ${result.requiredNodeVersion}`
@@ -6402,7 +6402,7 @@ function serviceRootCauseShape(graph, _origin, walk10) {
       const result = checkPackageConflict(conflict, declared, requiredDeclared);
       if (!result.compatible && result.reason) {
         return {
-          rootCauseNode: serviceId15,
+          rootCauseNode: serviceId16,
           rootCauseReason: result.reason,
           fixRecommendation: `Upgrade ${svc.name}'s ${conflict.requires.name} to >= ${conflict.requires.minVersion}`
         };
@@ -6507,9 +6507,9 @@ function rootCauseFromIncidents(nodeId, incidents, errorEvent) {
 function isFailingCallEdge(e) {
   return e.type === import_types8.EdgeType.CALLS && (e.signal?.errorCount ?? 0) > 0;
 }
-function callSourcesForService(graph, serviceId15) {
-  const ids = [serviceId15];
-  for (const edgeId of graph.outboundEdges(serviceId15)) {
+function callSourcesForService(graph, serviceId16) {
+  const ids = [serviceId16];
+  for (const edgeId of graph.outboundEdges(serviceId16)) {
     const e = graph.getEdgeAttributes(edgeId);
     if (e.type !== import_types8.EdgeType.CONTAINS) continue;
     const tgt = graph.getNodeAttributes(e.target);
@@ -6533,9 +6533,9 @@ function failingCallDominates(e, id, curEdge, curId) {
   }
   return id < curId;
 }
-function dominantFailingCall(graph, serviceId15, visited) {
+function dominantFailingCall(graph, serviceId16, visited) {
   let best = null;
-  for (const src of callSourcesForService(graph, serviceId15)) {
+  for (const src of callSourcesForService(graph, serviceId16)) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (!isFailingCallEdge(e)) continue;
@@ -6574,9 +6574,9 @@ function staleCallDominates(e, id, curEdge, curId) {
   if (ev !== cv) return ev > cv;
   return id < curId;
 }
-function dominantStaleCall(graph, serviceId15, visited) {
+function dominantStaleCall(graph, serviceId16, visited) {
   const bestByCallee = /* @__PURE__ */ new Map();
-  for (const src of callSourcesForService(graph, serviceId15)) {
+  for (const src of callSourcesForService(graph, serviceId16)) {
     for (const edgeId of graph.outboundEdges(src)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (e.type !== import_types8.EdgeType.CALLS) continue;
@@ -7399,6 +7399,53 @@ function detectColumnDrift(node) {
 function involvesNode(d, nodeId) {
   return d.source === nodeId || d.target === nodeId;
 }
+function datastoreEverObserved(graph, nodeId) {
+  if (!graph.hasNode(nodeId)) return false;
+  const n = graph.getNodeAttributes(nodeId);
+  if (n.type === import_types9.NodeType.DatabaseNode) {
+    const via = n.discoveredVia;
+    if (via === "otel" || via === "merged") return true;
+  }
+  for (const edgeId of graph.inboundEdges(nodeId)) {
+    const e = graph.getEdgeAttributes(edgeId);
+    if (e.provenance === import_types9.Provenance.OBSERVED || e.provenance === import_types9.Provenance.STALE) return true;
+  }
+  return false;
+}
+function serviceHasObservedSameEngineStore(graph, buckets2, serviceId16, engine, excludeTarget) {
+  for (const bucket of buckets2.values()) {
+    if (bucket.type !== import_types9.EdgeType.CONNECTS_TO) continue;
+    if (bucket.source !== serviceId16) continue;
+    if (bucket.target === excludeTarget) continue;
+    if (!graph.hasNode(bucket.target)) continue;
+    const target = graph.getNodeAttributes(bucket.target);
+    if (target.type !== import_types9.NodeType.DatabaseNode) continue;
+    if (target.engine !== engine) continue;
+    if (bucket.observed || datastoreEverObserved(graph, bucket.target)) return true;
+  }
+  return false;
+}
+var DEAD_CODE_PROBE_CONFIDENCE = 0.1;
+function dampenDeadCodeProbes(graph, buckets2, all) {
+  return all.map((d) => {
+    if (d.type !== "missing-observed") return d;
+    if (!d.extracted || d.edgeType !== import_types9.EdgeType.CONNECTS_TO) return d;
+    if (!graph.hasNode(d.target)) return d;
+    const target = graph.getNodeAttributes(d.target);
+    if (target.type !== import_types9.NodeType.DatabaseNode) return d;
+    if (d.extracted.evidence?.hostSource !== "literal") return d;
+    if (datastoreEverObserved(graph, d.target)) return d;
+    const engine = target.engine;
+    if (!serviceHasObservedSameEngineStore(graph, buckets2, d.source, engine, d.target)) return d;
+    const host = target.host ?? target.name;
+    return {
+      ...d,
+      confidence: Math.min(d.confidence, DEAD_CODE_PROBE_CONFIDENCE),
+      reason: `${d.source} declares a ${engine} connection to a hardcoded-literal host (${host}) that production has never observed, while it does observe another ${engine} store \u2014 this reads as a flag-gated or dead-code declaration (e.g. a fault-injection probe), not a real declared-vs-observed gap.`,
+      recommendation: "Confirm this is an intentional dead alternate \u2014 a fault-injection probe or a flag-gated branch. If it is meant to run in production, check the feature flag or conditional that gates it; if not, it can be ignored or removed."
+    };
+  });
+}
 function suppressHostMismatchHalves(all) {
   const observedHalf = /* @__PURE__ */ new Set();
   const declaredHalf = /* @__PURE__ */ new Set();
@@ -7435,7 +7482,8 @@ function computeDivergences(graph, opts = {}) {
     }
   });
   const reconciled = suppressHostMismatchHalves(all);
-  let filtered = reconciled;
+  const dampened = dampenDeadCodeProbes(graph, buckets2, reconciled);
+  let filtered = dampened;
   if (opts.type) {
     const allowed = opts.type;
     filtered = filtered.filter((d) => allowed.has(d.type));
@@ -8431,9 +8479,9 @@ var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
   "StatefulSet",
   "DaemonSet"
 ]);
-function addAliases(graph, serviceId15, candidates) {
-  if (!graph.hasNode(serviceId15)) return;
-  const node = graph.getNodeAttributes(serviceId15);
+function addAliases(graph, serviceId16, candidates) {
+  if (!graph.hasNode(serviceId16)) return;
+  const node = graph.getNodeAttributes(serviceId16);
   if (node.type !== import_types20.NodeType.ServiceNode) return;
   const set = new Set(node.aliases ?? []);
   for (const c of candidates) {
@@ -8443,7 +8491,7 @@ function addAliases(graph, serviceId15, candidates) {
   }
   if (set.size === 0) return;
   const updated = { ...node, aliases: [...set].sort() };
-  graph.replaceNodeAttributes(serviceId15, updated);
+  graph.replaceNodeAttributes(serviceId16, updated);
 }
 function indexServicesByName(services) {
   const map = /* @__PURE__ */ new Map();
@@ -8476,12 +8524,12 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   }
   if (!compose?.services) return;
   for (const [composeName, svc] of Object.entries(compose.services)) {
-    const serviceId15 = serviceIndex.get(composeName);
-    if (!serviceId15) continue;
+    const serviceId16 = serviceIndex.get(composeName);
+    if (!serviceId16) continue;
     const aliases = /* @__PURE__ */ new Set([composeName]);
     if (svc.container_name) aliases.add(svc.container_name);
     if (svc.hostname) aliases.add(svc.hostname);
-    addAliases(graph, serviceId15, aliases);
+    addAliases(graph, serviceId16, aliases);
   }
 }
 var LABEL_KEYS = /* @__PURE__ */ new Set([
@@ -10471,12 +10519,12 @@ async function resolveConfigs(literals, keys, serviceDir, looksLike, parse11) {
     const value = await interpolateEnvRefs(raw, serviceDir);
     if (!looksLike(value)) continue;
     const parsed = parse11(value);
-    if (parsed) out.push(parsed);
+    if (parsed) out.push({ ...parsed, hostSource: "config" });
   }
   for (const lit of literals) {
     if (!looksLike(lit)) continue;
     const parsed = parse11(lit);
-    if (parsed) out.push(parsed);
+    if (parsed) out.push({ ...parsed, hostSource: "literal" });
   }
   return out;
 }
@@ -10745,7 +10793,10 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
         type: import_types24.EdgeType.CONNECTS_TO,
         provenance: import_types24.Provenance.EXTRACTED,
         confidence: (0, import_types24.confidenceForExtracted)("structural"),
-        evidence: { file: evidenceFile }
+        // Carry how the host was recovered (ADR-213) so the divergence ranker
+        // can tell a real declared store from a hardcoded fault-injection /
+        // flag-gated probe. Only set when the parser distinguished the two.
+        evidence: config.hostSource ? { file: evidenceFile, hostSource: config.hostSource } : { file: evidenceFile }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -16268,6 +16319,639 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   return result;
 }
 
+// src/ask.ts
+init_cjs_shims();
+var import_types58 = require("@neat.is/types");
+var DEFAULT_MAX_NODES = 3;
+var MAX_FACTS_PER_SECTION = 6;
+var INTENT_RULES = [
+  {
+    intent: "root-cause",
+    test: /\b(why|root[\s-]?cause|failing|fail(?:s|ed)?|breaking|broke(?:n)?|crash(?:ing|ed)?|throw(?:ing|s)?|culprit|5\d\d)\b/
+  },
+  {
+    intent: "blast-radius",
+    test: /\b(blast|break[\s-]?if|breaks[\s-]?if|impact|downstream|dependents?|redeploy|who\s+(?:uses|calls|depends)|what\s+depends\s+on|affect(?:s|ed)?)\b/
+  },
+  {
+    intent: "divergence",
+    test: /\b(diverg\w*|weird|mismatch|drift|out\s+of\s+sync|inconsistent|disagree\w*|declared\s+vs|anything\s+wrong)\b/
+  },
+  {
+    intent: "incidents",
+    test: /\b(incidents?|recent\s+(?:errors?|failures?)|error\s+history|failure\s+history)\b/
+  },
+  {
+    intent: "observed",
+    test: /\b(at\s+runtime|in\s+prod(?:uction)?|actually\s+call\w*|really\s+call\w*|observed|runtime\s+traffic)\b/
+  },
+  {
+    intent: "dependencies",
+    test: /\b(depend\w*|calls?|uses?|imports?|relies\s+on|needs?)\b/
+  }
+];
+function classifyIntent(question) {
+  const q = question.toLowerCase();
+  for (const rule of INTENT_RULES) {
+    if (rule.test.test(q)) return rule.intent;
+  }
+  return "overview";
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "for",
+  "with",
+  "and",
+  "or",
+  "but",
+  "if",
+  "as",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "do",
+  "does",
+  "did",
+  "has",
+  "have",
+  "had",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "how",
+  "when",
+  "where",
+  "my",
+  "me",
+  "i",
+  "we",
+  "you",
+  "they",
+  "them",
+  "from",
+  "into",
+  "about",
+  "would",
+  "will",
+  "can",
+  "could",
+  "should",
+  "anything",
+  "everything",
+  "something",
+  "all",
+  "any",
+  "some",
+  "no",
+  "not",
+  "so",
+  "up",
+  "out",
+  "over",
+  "get",
+  "got",
+  "show",
+  "tell",
+  "explain",
+  "find",
+  "give",
+  "happen",
+  "happens",
+  "happening",
+  "here",
+  "there",
+  "system",
+  "code",
+  "service",
+  "node",
+  "graph"
+]);
+var INTENT_WORDS = /* @__PURE__ */ new Set([
+  "why",
+  "root",
+  "cause",
+  "failing",
+  "fail",
+  "fails",
+  "failed",
+  "breaking",
+  "broke",
+  "broken",
+  "crash",
+  "crashing",
+  "crashed",
+  "throw",
+  "throwing",
+  "throws",
+  "culprit",
+  "blast",
+  "radius",
+  "break",
+  "breaks",
+  "impact",
+  "downstream",
+  "dependent",
+  "dependents",
+  "redeploy",
+  "affect",
+  "affects",
+  "affected",
+  "diverge",
+  "divergence",
+  "divergences",
+  "weird",
+  "mismatch",
+  "drift",
+  "inconsistent",
+  "disagree",
+  "declared",
+  "observed",
+  "incident",
+  "incidents",
+  "recent",
+  "errors",
+  "error",
+  "failures",
+  "failure",
+  "history",
+  "runtime",
+  "production",
+  "prod",
+  "traffic",
+  "actually",
+  "really",
+  "depend",
+  "depends",
+  "dependency",
+  "dependencies",
+  "call",
+  "calls",
+  "use",
+  "uses",
+  "using",
+  "import",
+  "imports",
+  "relies",
+  "rely",
+  "needs",
+  "need",
+  "sync"
+]);
+function tokens(input) {
+  const spaced = input.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+  return (spaced.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter((t) => t.length >= 2);
+}
+function queryTokens(question) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const t of tokens(question)) {
+    if (STOPWORDS.has(t) || INTENT_WORDS.has(t)) continue;
+    if (seen.has(t)) continue;
+    seen.add(t);
+    out.push(t);
+  }
+  return out;
+}
+function nodeName(node) {
+  return node.name ?? node.id;
+}
+function idBody(id) {
+  const colon = id.indexOf(":");
+  return colon >= 0 ? id.slice(colon + 1) : id;
+}
+var EMBED_MIN_SCORE = 0.35;
+async function resolveEntities(graph, question, searchIndex, maxNodes) {
+  const qTokens = queryTokens(question);
+  const normalized = question.toLowerCase();
+  const best = /* @__PURE__ */ new Map();
+  const consider = (cand) => {
+    const cur = best.get(cand.nodeId);
+    if (!cur || cand.score > cur.score) best.set(cand.nodeId, cand);
+  };
+  graph.forEachNode((id, attrs) => {
+    const node = attrs;
+    if (node.type === import_types58.NodeType.FrontierNode) return;
+    const name = nodeName(node);
+    const body = idBody(id);
+    const labelTokens = /* @__PURE__ */ new Set([...tokens(body), ...tokens(name)]);
+    if (labelTokens.size === 0) return;
+    let matched = 0;
+    for (const t of qTokens) if (labelTokens.has(t)) matched += 1;
+    const named = body.length >= 2 && normalized.includes(body.toLowerCase()) || name.length >= 2 && normalized.includes(name.toLowerCase());
+    if (matched === 0 && !named) return;
+    const coverage = qTokens.length > 0 ? matched / qTokens.length : 0;
+    const via = named ? "id" : matched > 0 && tokens(name).some((t) => qTokens.includes(t)) ? "label" : "token";
+    const score = named ? Math.max(0.9, coverage) : Math.min(0.85, 0.3 + 0.7 * coverage);
+    consider({ nodeId: id, label: name, via, score: Math.min(1, score) });
+  });
+  if (searchIndex) {
+    try {
+      const res = await searchIndex.search(question, 10);
+      if (res.provider !== "substring") {
+        for (const m of res.matches) {
+          if (m.node.type === import_types58.NodeType.FrontierNode) continue;
+          const already = best.get(m.node.id);
+          if (!already && m.score < EMBED_MIN_SCORE) continue;
+          consider({
+            nodeId: m.node.id,
+            label: nodeName(m.node),
+            via: "embedding",
+            score: Math.max(0, Math.min(1, m.score))
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const viaRank = { id: 3, label: 2, token: 1, embedding: 0 };
+  return [...best.values()].sort(
+    (a, b) => b.score - a.score || viaRank[b.via] - viaRank[a.via] || a.nodeId.localeCompare(b.nodeId)
+  ).slice(0, maxNodes).map((s) => ({ nodeId: s.nodeId, label: s.label, via: s.via, score: Number(s.score.toFixed(3)) }));
+}
+function incidentsForNode(nodeId, incidents) {
+  if (!incidents || incidents.length === 0) return [];
+  const svc = nodeId.replace(/^service:/, "");
+  return incidents.filter((e) => e.affectedNode === nodeId || e.service === svc);
+}
+function edgeSignalNote(e) {
+  const bits = [];
+  if (e.signal) {
+    bits.push(`${e.signal.spanCount} spans`);
+    if (e.signal.errorCount > 0) bits.push(`${e.signal.errorCount} errors`);
+    if (e.signal.latencyMs?.p95 !== void 0) bits.push(`p95 ${Math.round(e.signal.latencyMs.p95)}ms`);
+  } else if (e.callCount !== void 0) {
+    bits.push(`${e.callCount} calls`);
+  }
+  return bits.length ? ` (${bits.join(", ")})` : "";
+}
+function buildRootCauseSection(graph, node, incidents, now) {
+  const result = getRootCause(graph, node, void 0, incidents, { now });
+  if (!result) return null;
+  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? import_types58.Provenance.OBSERVED;
+  const facts = [
+    {
+      text: `Root cause: ${result.rootCauseNode} \u2014 ${result.rootCauseReason}`,
+      provenance: lastProv,
+      confidence: result.confidence
+    }
+  ];
+  const candidates = result.candidates ?? [];
+  for (const c of candidates.slice(0, 3)) {
+    facts.push({
+      text: `Candidate ${c.node} \u2014 ${c.classification}: ${c.reason}`,
+      ...c.provenance ? { provenance: c.provenance } : {},
+      confidence: c.confidence
+    });
+  }
+  if (result.traversalPath.length > 1) {
+    facts.push({ text: `Traversal: ${result.traversalPath.join(" \u2190 ")}` });
+  }
+  if (result.fixRecommendation) {
+    facts.push({ text: `Recommended fix: ${result.fixRecommendation}` });
+  }
+  return { heading: "Root cause (navigation)", facts: facts.slice(0, MAX_FACTS_PER_SECTION) };
+}
+function buildDependenciesSection(graph, node) {
+  const result = getTransitiveDependencies(graph, node, 2);
+  if (result.total === 0) return null;
+  const facts = result.dependencies.slice(0, MAX_FACTS_PER_SECTION).map((d) => ({
+    text: `${d.nodeId} \u2014 ${d.edgeType} (distance ${d.distance})`,
+    // Per-fact provenance: the transitive walk mixes EXTRACTED and OBSERVED
+    // edges, so the tag is on the fact, not asserted for the whole section.
+    provenance: d.provenance
+  }));
+  return { heading: "Dependencies", facts };
+}
+function buildObservedSection(graph, node) {
+  const result = getObservedDependencies(graph, node);
+  const facts = [];
+  for (const e of result.dependencies.slice(0, MAX_FACTS_PER_SECTION)) {
+    const via = e.source !== node ? ` via ${e.source}` : "";
+    facts.push({
+      text: `calls ${e.target}${via}${edgeSignalNote(e)}`,
+      provenance: e.provenance,
+      confidence: confidenceForEdge(e)
+    });
+  }
+  if (facts.length === 0) {
+    if (result.observed && result.inboundObservedCount > 0) {
+      facts.push({
+        text: `no outbound runtime calls, but OTel observed ${result.inboundObservedCount} inbound call path${result.inboundObservedCount === 1 ? "" : "s"} \u2014 a pure receiver`,
+        provenance: import_types58.Provenance.OBSERVED
+      });
+    } else {
+      return null;
+    }
+  }
+  return { heading: "Runtime dependencies (OBSERVED)", facts };
+}
+function buildBlastSection(graph, node) {
+  const result = getBlastRadius(graph, node);
+  if (result.totalAffected === 0) return null;
+  const facts = result.affectedNodes.slice(0, MAX_FACTS_PER_SECTION).map((n) => ({
+    text: `${n.nodeId} (distance ${n.distance})`,
+    provenance: n.edgeProvenance,
+    confidence: n.confidence
+  }));
+  return {
+    heading: `Blast radius \u2014 ${result.totalAffected} dependent${result.totalAffected === 1 ? "" : "s"}`,
+    facts
+  };
+}
+function buildIncidentsSection(node, incidents) {
+  const relevant = incidentsForNode(node, incidents);
+  if (relevant.length === 0) return null;
+  const ordered = [...relevant].sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, 4);
+  const facts = ordered.map((ev) => ({
+    text: `${ev.timestamp} \u2014 ${ev.service}: ${ev.errorMessage}`,
+    // ErrorEvents are observation records — OBSERVED by definition.
+    provenance: import_types58.Provenance.OBSERVED
+  }));
+  return { heading: `Recent incidents (OBSERVED) \u2014 ${relevant.length} recorded`, facts };
+}
+function divergenceLine(d) {
+  if ((d.type === "missing-observed" || d.type === "missing-extracted") && d.column) {
+    return `[${d.type}] ${d.table ?? d.source} column ${d.column} \u2014 ${d.reason}`;
+  }
+  return `[${d.type}] ${d.source} \u2192 ${d.target} \u2014 ${d.reason}`;
+}
+function buildDivergenceSection(graph, node) {
+  const result = computeDivergences(graph, { node });
+  if (result.totalAffected === 0) return null;
+  const facts = result.divergences.slice(0, MAX_FACTS_PER_SECTION).map((d) => ({
+    text: divergenceLine(d),
+    confidence: d.confidence
+    // A divergence is composite by construction (EXTRACTED vs OBSERVED), so it
+    // carries no single provenance — the fact leaves it unset.
+  }));
+  return {
+    heading: `Divergences (EXTRACTED vs OBSERVED) \u2014 ${result.totalAffected}`,
+    facts
+  };
+}
+function buildGlobalDivergenceSection(graph) {
+  const result = computeDivergences(graph);
+  if (result.totalAffected === 0) {
+    return {
+      heading: "Divergences (EXTRACTED vs OBSERVED)",
+      facts: [{ text: "None \u2014 declared code and observed runtime agree across the graph." }]
+    };
+  }
+  const facts = result.divergences.slice(0, MAX_FACTS_PER_SECTION).map((d) => ({
+    text: divergenceLine(d),
+    confidence: d.confidence
+    // Composite by construction (EXTRACTED vs OBSERVED), so no single provenance.
+  }));
+  return {
+    heading: `Divergences (EXTRACTED vs OBSERVED) \u2014 ${result.totalAffected}`,
+    facts
+  };
+}
+function buildGlobalIncidentsSection(incidents) {
+  if (!incidents || incidents.length === 0) {
+    return {
+      heading: "Incidents across the system",
+      facts: [{ text: "None recorded \u2014 the OBSERVED incident store is empty." }]
+    };
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  for (const ev of incidents) {
+    const key = ev.affectedNode || (0, import_types58.serviceId)(ev.service);
+    const cur = byKey.get(key);
+    if (!cur) {
+      byKey.set(key, { key, count: 1, latest: ev.timestamp, sampleMsg: ev.errorMessage });
+    } else {
+      cur.count += 1;
+      if (ev.timestamp > cur.latest) {
+        cur.latest = ev.timestamp;
+        cur.sampleMsg = ev.errorMessage;
+      }
+    }
+  }
+  const rows = [...byKey.values()].sort((a, b) => b.count - a.count || b.latest.localeCompare(a.latest) || a.key.localeCompare(b.key)).slice(0, MAX_FACTS_PER_SECTION);
+  const facts = rows.map((r) => ({
+    text: `${r.key} \u2014 ${r.count} incident${r.count === 1 ? "" : "s"}, latest ${r.latest}: ${r.sampleMsg}`,
+    provenance: import_types58.Provenance.OBSERVED
+  }));
+  return {
+    heading: `Incidents across the system \u2014 ${incidents.length} recorded`,
+    facts
+  };
+}
+function buildOverviewSections(graph, incidents) {
+  const nodeByType = /* @__PURE__ */ new Map();
+  const services = [];
+  graph.forEachNode((_id, attrs) => {
+    const node = attrs;
+    nodeByType.set(node.type, (nodeByType.get(node.type) ?? 0) + 1);
+    if (node.type === import_types58.NodeType.ServiceNode) services.push(node.id);
+  });
+  const edgeByProv = /* @__PURE__ */ new Map();
+  graph.forEachEdge((_id, attrs) => {
+    const p = attrs.provenance;
+    edgeByProv.set(p, (edgeByProv.get(p) ?? 0) + 1);
+  });
+  const sections = [];
+  const count = (t) => nodeByType.get(t) ?? 0;
+  const shapeFacts = [
+    { text: `${graph.order} nodes, ${graph.size} edges` },
+    {
+      text: `${count(import_types58.NodeType.ServiceNode)} services, ${count(import_types58.NodeType.FileNode)} files, ${count(import_types58.NodeType.SymbolNode)} symbols, ${count(import_types58.NodeType.DatabaseNode)} databases`
+    }
+  ];
+  for (const p of [import_types58.Provenance.EXTRACTED, import_types58.Provenance.OBSERVED, import_types58.Provenance.INFERRED, import_types58.Provenance.STALE]) {
+    const n = edgeByProv.get(p) ?? 0;
+    if (n > 0) shapeFacts.push({ text: `${n} ${p} edge${n === 1 ? "" : "s"}`, provenance: p });
+  }
+  sections.push({ heading: "System shape", facts: shapeFacts });
+  const depCounts = services.map((s) => ({ s, n: getTransitiveDependencies(graph, s, 1).total })).filter((r) => r.n > 0).sort((a, b) => b.n - a.n || a.s.localeCompare(b.s)).slice(0, MAX_FACTS_PER_SECTION);
+  if (depCounts.length > 0) {
+    sections.push({
+      heading: "Busiest services (by direct dependencies)",
+      facts: depCounts.map((r) => ({
+        text: `${r.s} \u2014 ${r.n} direct dependenc${r.n === 1 ? "y" : "ies"}`
+      }))
+    });
+  }
+  if (incidents && incidents.length > 0) {
+    const incCount = /* @__PURE__ */ new Map();
+    for (const ev of incidents) {
+      const key = ev.affectedNode || (0, import_types58.serviceId)(ev.service);
+      incCount.set(key, (incCount.get(key) ?? 0) + 1);
+    }
+    const top = [...incCount.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_FACTS_PER_SECTION);
+    sections.push({
+      heading: `Nodes with incidents \u2014 ${incidents.length} recorded`,
+      facts: top.map(([k, n]) => ({
+        text: `${k} \u2014 ${n} incident${n === 1 ? "" : "s"}`,
+        provenance: import_types58.Provenance.OBSERVED
+      }))
+    });
+  }
+  const div = computeDivergences(graph);
+  sections.push({
+    heading: "Divergences",
+    facts: [
+      {
+        text: div.totalAffected === 0 ? "None \u2014 declared code and observed runtime agree across the graph." : `${div.totalAffected} divergence${div.totalAffected === 1 ? "" : "s"} between declared code and observed runtime \u2014 ask "are there any divergences?" for the list.`
+      }
+    ]
+  });
+  return sections;
+}
+function buildGlobalSections(intent, graph, incidents) {
+  switch (intent) {
+    case "divergence":
+      return [buildGlobalDivergenceSection(graph)];
+    case "incidents":
+      return [buildGlobalIncidentsSection(incidents)];
+    case "overview":
+      return buildOverviewSections(graph, incidents);
+    default:
+      return null;
+  }
+}
+var SECTION_ORDER = {
+  "root-cause": ["root-cause", "incidents", "blast", "observed", "divergence"],
+  "blast-radius": ["blast", "dependencies", "observed", "incidents"],
+  dependencies: ["dependencies", "observed", "blast"],
+  observed: ["observed", "dependencies", "incidents"],
+  incidents: ["incidents", "root-cause", "observed"],
+  divergence: ["divergence", "observed", "dependencies", "incidents"],
+  overview: ["dependencies", "observed", "blast", "incidents", "divergence"]
+};
+function buildSection(kind, graph, node, incidents, now) {
+  switch (kind) {
+    case "root-cause":
+      return buildRootCauseSection(graph, node, incidents, now);
+    case "dependencies":
+      return buildDependenciesSection(graph, node);
+    case "observed":
+      return buildObservedSection(graph, node);
+    case "blast":
+      return buildBlastSection(graph, node);
+    case "incidents":
+      return buildIncidentsSection(node, incidents);
+    case "divergence":
+      return buildDivergenceSection(graph, node);
+  }
+}
+function summarizeGlobal(intent, sections) {
+  const lead = sections[0];
+  switch (intent) {
+    case "divergence": {
+      const none = lead?.facts[0]?.text.startsWith("None") ?? true;
+      return none ? "No divergences across the graph \u2014 declared code and observed runtime agree." : `${lead.heading} across the graph, highest-confidence first below.`;
+    }
+    case "incidents": {
+      const none = lead?.facts[0]?.text.startsWith("None") ?? true;
+      return none ? "No incidents recorded across the system \u2014 the OBSERVED incident store is empty." : `${lead.heading}, aggregated by node below.`;
+    }
+    case "overview":
+    default:
+      return `System overview across the whole graph: ${sections.length} view${sections.length === 1 ? "" : "s"} below \u2014 shape (nodes/edges by provenance), busiest services, incidents, and divergences.`;
+  }
+}
+function summarize(question, intent, matched, primary, sections, scope) {
+  if (scope === "global") {
+    return summarizeGlobal(intent, sections);
+  }
+  if (!primary) {
+    return `Nothing in "${question}" resolved to a node in the graph. Name a service, file, route, or table \u2014 e.g. \`ask "what does <service> depend on?"\`. For a graph-wide look, ask for an overview, divergences, or incidents.`;
+  }
+  const lead = sections[0];
+  const others = matched.slice(1);
+  const alsoNote = others.length ? ` Also matched: ${others.map((m) => m.nodeId).join(", ")}.` : "";
+  let core;
+  switch (intent) {
+    case "root-cause": {
+      const rc = sections.find((s) => s.heading === "Root cause (navigation)");
+      if (rc) {
+        core = rc.facts[0]?.text ?? "";
+      } else if (lead) {
+        core = `No root cause surfaced for ${primary} \u2014 it may be healthy, or the failure isn't recorded. Nearest context: ${lead.heading.toLowerCase()}.`;
+      } else {
+        core = `No root cause surfaced for ${primary} \u2014 it may be healthy.`;
+      }
+      break;
+    }
+    case "blast-radius":
+      core = lead ? `${lead.heading} of ${primary}.` : `${primary} has no dependents \u2014 nothing else would break if it failed.`;
+      break;
+    case "dependencies":
+      core = lead ? `${primary}: ${lead.heading.toLowerCase()} listed below.` : `${primary} has no declared dependencies in the graph.`;
+      break;
+    case "observed":
+      core = lead ? `${primary} at runtime: ${lead.facts.length} OBSERVED fact${lead.facts.length === 1 ? "" : "s"}.` : `No runtime traffic OBSERVED for ${primary}.`;
+      break;
+    case "incidents":
+      core = lead ? `${primary}: ${lead.heading.toLowerCase()}.` : `No incidents recorded against ${primary}.`;
+      break;
+    case "divergence":
+      core = lead ? `${lead.heading} involving ${primary}.` : `No divergences involve ${primary} \u2014 declared and observed agree here.`;
+      break;
+    default:
+      core = `${primary}: ${sections.length} view${sections.length === 1 ? "" : "s"} of its fused local context below.`;
+  }
+  return `${core}${alsoNote}`;
+}
+async function askGraph(graph, question, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const maxNodes = opts.maxNodes ?? DEFAULT_MAX_NODES;
+  const intent = classifyIntent(question);
+  const matched = await resolveEntities(graph, question, opts.searchIndex, maxNodes);
+  const primary = matched[0]?.nodeId;
+  const sections = [];
+  let scope;
+  if (primary) {
+    scope = "node";
+    for (const kind of SECTION_ORDER[intent]) {
+      const s = buildSection(kind, graph, primary, opts.incidents, now);
+      if (s && s.facts.length > 0) sections.push(s);
+    }
+  } else {
+    const global = buildGlobalSections(intent, graph, opts.incidents);
+    if (global) {
+      scope = "global";
+      for (const s of global) if (s.facts.length > 0) sections.push(s);
+    }
+  }
+  const answer = summarize(question, intent, matched, primary, sections, scope);
+  const provSet = /* @__PURE__ */ new Set();
+  for (const s of sections) for (const f of s.facts) if (f.provenance) provSet.add(f.provenance);
+  const confidence = sections[0]?.facts[0]?.confidence;
+  return import_types58.AskResultSchema.parse({
+    question,
+    intent,
+    matched,
+    ...primary ? { primaryNode: primary } : {},
+    ...scope ? { scope } : {},
+    sections,
+    answer,
+    ...confidence !== void 0 ? { confidence } : {},
+    provenance: [...provSet]
+  });
+}
+
 // src/diff.ts
 init_cjs_shims();
 var import_node_fs35 = require("fs");
@@ -16349,7 +17033,7 @@ function canonicalJson(value) {
 init_cjs_shims();
 var import_node_fs36 = require("fs");
 var import_node_path70 = __toESM(require("path"), 1);
-var import_types58 = require("@neat.is/types");
+var import_types59 = require("@neat.is/types");
 var SCHEMA_VERSION = 7;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -16373,7 +17057,7 @@ function migrateV5ToV6(payload) {
   if (Array.isArray(nodes)) {
     for (const node of nodes) {
       const attrs = node.attributes;
-      if (!attrs || attrs.type !== import_types58.NodeType.InfraNode) continue;
+      if (!attrs || attrs.type !== import_types59.NodeType.InfraNode) continue;
       if (attrs.kind !== "sql-table" && attrs.kind !== "supabase-table") continue;
       if (!Array.isArray(attrs.columns)) attrs.columns = [];
     }
@@ -16389,12 +17073,12 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = import_types58.Provenance.OBSERVED;
+      attrs.provenance = import_types59.Provenance.OBSERVED;
       const type = typeof attrs.type === "string" ? attrs.type : void 0;
       const source = typeof attrs.source === "string" ? attrs.source : void 0;
       const target = typeof attrs.target === "string" ? attrs.target : void 0;
       if (type && source && target) {
-        const newId = (0, import_types58.observedEdgeId)(source, target, type);
+        const newId = (0, import_types59.observedEdgeId)(source, target, type);
         attrs.id = newId;
         if (edge.key) edge.key = newId;
       }
@@ -16552,7 +17236,7 @@ init_cjs_shims();
 var import_node_fs37 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path72 = __toESM(require("path"), 1);
-var import_types59 = require("@neat.is/types");
+var import_types60 = require("@neat.is/types");
 function neatHome() {
   const override = process.env.NEAT_HOME;
   if (override && override.length > 0) return import_node_path72.default.resolve(override);
@@ -16642,7 +17326,7 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types59.RegistryFileSchema.parse(parsed);
+  return import_types60.RegistryFileSchema.parse(parsed);
 }
 async function getProject(name) {
   const reg = await readRegistry();
@@ -16923,15 +17607,15 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 
 // src/connectors/index.ts
 init_cjs_shims();
-var import_types60 = require("@neat.is/types");
+var import_types61 = require("@neat.is/types");
 var NO_ENV = "unknown";
 function staticCallSiteFor(graph, serviceName, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
   const sites = [];
   for (const edgeId of graph.inboundEdges(targetNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.provenance !== import_types60.Provenance.EXTRACTED) continue;
-    const parsed = (0, import_types60.parseFileId)(edge.source);
+    if (edge.provenance !== import_types61.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types61.parseFileId)(edge.source);
     if (!parsed || parsed.service !== serviceName || !edge.evidence) continue;
     const site = { relPath: edge.evidence.file };
     if (edge.evidence.line !== void 0) site.line = edge.evidence.line;
@@ -16942,7 +17626,7 @@ function staticCallSiteFor(graph, serviceName, targetNodeId) {
 function routeCallSiteFor(graph, targetNodeId) {
   if (!graph.hasNode(targetNodeId)) return void 0;
   const attrs = graph.getNodeAttributes(targetNodeId);
-  if (attrs.type !== import_types60.NodeType.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== import_types61.NodeType.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -17513,23 +18197,23 @@ async function fetchPgStatStatements(connectionString, limit = DEFAULT_STATEMENT
 
 // src/connectors/supabase/resolve.ts
 init_cjs_shims();
-var import_types62 = require("@neat.is/types");
+var import_types63 = require("@neat.is/types");
 function createSupabaseResolveTarget(graph, config) {
   return (signal, _ctx) => {
     if (signal.targetKind !== SUPABASE_TABLE_TARGET_KIND && signal.targetKind !== SUPABASE_RPC_TARGET_KIND) {
       return null;
     }
-    const subResourceId = (0, import_types62.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
+    const subResourceId = (0, import_types63.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
     if (graph.hasNode(subResourceId)) {
-      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types62.EdgeType.CALLS };
+      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types63.EdgeType.CALLS };
     }
-    const bareResourceId = (0, import_types62.infraId)(signal.targetKind, signal.targetName);
+    const bareResourceId = (0, import_types63.infraId)(signal.targetKind, signal.targetName);
     if (graph.hasNode(bareResourceId)) {
-      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types62.EdgeType.CALLS };
+      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types63.EdgeType.CALLS };
     }
-    const projectLevelId = (0, import_types62.infraId)("supabase", config.nodeRef);
+    const projectLevelId = (0, import_types63.infraId)("supabase", config.nodeRef);
     if (graph.hasNode(projectLevelId)) {
-      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types62.EdgeType.CALLS };
+      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types63.EdgeType.CALLS };
     }
     return null;
   };
@@ -17622,7 +18306,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 
 // src/connectors/railway/index.ts
 init_cjs_shims();
-var import_types66 = require("@neat.is/types");
+var import_types67 = require("@neat.is/types");
 
 // src/connectors/railway/client.ts
 init_cjs_shims();
@@ -17773,7 +18457,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types66.NodeType.RouteNode) return;
+    if (node.type !== import_types67.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -17877,12 +18561,12 @@ function createRailwayResolveTarget(config) {
     const serviceName = config.serviceNameById[config.serviceId];
     if (!serviceName) return null;
     if (signal.targetKind === ROUTE_TARGET_KIND) {
-      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types66.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types67.EdgeType.CALLS };
     }
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: (0, import_types66.serviceId)(peerName), serviceName, edgeType: import_types66.EdgeType.CONNECTS_TO };
+      return { targetNodeId: (0, import_types67.serviceId)(peerName), serviceName, edgeType: import_types67.EdgeType.CONNECTS_TO };
     }
     return null;
   };
@@ -18070,7 +18754,7 @@ function mapLogEntriesToSignals(entries) {
 
 // src/connectors/firebase/resolve.ts
 init_cjs_shims();
-var import_types67 = require("@neat.is/types");
+var import_types68 = require("@neat.is/types");
 function neatServiceNameFor(resourceType, resourceName, serviceMap) {
   switch (resourceType) {
     case "cloud_function":
@@ -18085,7 +18769,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types67.NodeType.RouteNode) return;
+    if (node.type !== import_types68.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -18117,7 +18801,7 @@ function createFirebaseResolveTarget(graph, serviceMap) {
     return {
       targetNodeId: match.routeNodeId,
       serviceName,
-      edgeType: import_types67.EdgeType.CALLS
+      edgeType: import_types68.EdgeType.CALLS
     };
   };
 }
@@ -18144,7 +18828,7 @@ init_cjs_shims();
 
 // src/connectors/cloudflare/connector.ts
 init_cjs_shims();
-var import_types69 = require("@neat.is/types");
+var import_types70 = require("@neat.is/types");
 
 // src/connectors/cloudflare/client.ts
 init_cjs_shims();
@@ -18308,7 +18992,7 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === import_types69.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === import_types70.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
@@ -18320,7 +19004,7 @@ function findMatchingRouteNode(graph, serviceName, method, path76) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types69.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types70.NodeType.RouteNode || a.service !== serviceName) return;
     if (!a.pathTemplate || normalizePathTemplate(a.pathTemplate) !== normalizedPath) return;
     const routeMethod = (a.method ?? "").toUpperCase();
     if (routeMethod !== "ALL" && routeMethod !== method) return;
@@ -18339,11 +19023,11 @@ function createCloudflareResolveTarget(config, graph) {
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
-      const wholeFileId = (0, import_types69.fileId)(mapping.service, mapping.entryFile);
+      const wholeFileId = (0, import_types70.fileId)(mapping.service, mapping.entryFile);
       return {
         targetNodeId: resolveRouteGrain(mapping.service, wholeFileId),
         serviceName: mapping.service,
-        edgeType: import_types69.EdgeType.CALLS
+        edgeType: import_types70.EdgeType.CALLS
       };
     }
     const taggedFileId = findTaggedWorkerFileNode(graph, scriptName);
@@ -18352,13 +19036,13 @@ function createCloudflareResolveTarget(config, graph) {
       return {
         targetNodeId: resolveRouteGrain(fileNode.service, taggedFileId),
         serviceName: fileNode.service,
-        edgeType: import_types69.EdgeType.CALLS
+        edgeType: import_types70.EdgeType.CALLS
       };
     }
     return {
-      targetNodeId: (0, import_types69.infraId)("cloudflare-worker", scriptName),
+      targetNodeId: (0, import_types70.infraId)("cloudflare-worker", scriptName),
       serviceName: scriptName,
-      edgeType: import_types69.EdgeType.CALLS,
+      edgeType: import_types70.EdgeType.CALLS,
       ensureInfraNode: { kind: "cloudflare-worker", name: scriptName, provider: "cloudflare" }
     };
   };
@@ -18554,14 +19238,14 @@ function diffNeonStatementsToSignals(rows, previous, observedAtIso) {
 
 // src/connectors/neon/resolve.ts
 init_cjs_shims();
-var import_types73 = require("@neat.is/types");
+var import_types74 = require("@neat.is/types");
 function createNeonResolveTarget(config) {
   return (signal) => {
     if (signal.targetKind !== NEON_SQL_TABLE_TARGET_KIND || !signal.targetName) return null;
     return {
-      targetNodeId: (0, import_types73.infraId)("sql-table", signal.targetName),
+      targetNodeId: (0, import_types74.infraId)("sql-table", signal.targetName),
       serviceName: config.serviceName,
-      edgeType: import_types73.EdgeType.CALLS,
+      edgeType: import_types74.EdgeType.CALLS,
       ensureInfraNode: { kind: "sql-table", name: signal.targetName, provider: "neon" }
     };
   };
@@ -18742,14 +19426,14 @@ function mapLogEntriesToSignals2(entries) {
 
 // src/connectors/cloud-run/resolve.ts
 init_cjs_shims();
-var import_types77 = require("@neat.is/types");
+var import_types78 = require("@neat.is/types");
 var CLOUD_RUN_SERVICE_INFRA_KIND = "cloud-run-service";
 function findMatchingRouteNode2(graph, serviceName, method, normalizedPath) {
   let found = null;
   graph.forEachNode((_id, attrs) => {
     if (found) return;
     const node = attrs;
-    if (node.type !== import_types77.NodeType.RouteNode) return;
+    if (node.type !== import_types78.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -18774,13 +19458,13 @@ function createCloudRunResolveTarget(graph, config) {
         normalizePathTemplate(path76)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types77.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types78.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types77.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
+      targetNodeId: (0, import_types78.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
       serviceName: mappedService ?? gcpServiceName,
-      edgeType: import_types77.EdgeType.CALLS,
+      edgeType: import_types78.EdgeType.CALLS,
       ensureInfraNode: {
         kind: CLOUD_RUN_SERVICE_INFRA_KIND,
         name: gcpServiceName,
@@ -18821,7 +19505,7 @@ function createCloudRunConnector(graph, config = {}) {
 
 // src/connectors/render/index.ts
 init_cjs_shims();
-var import_types80 = require("@neat.is/types");
+var import_types81 = require("@neat.is/types");
 
 // src/connectors/render/types.ts
 init_cjs_shims();
@@ -18899,7 +19583,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types80.NodeType.RouteNode) return;
+    if (node.type !== import_types81.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -18984,7 +19668,7 @@ function mapRenderRequestLogsToSignals(entries, routeIndex) {
 function createRenderResolveTarget(config) {
   return (signal) => {
     if (signal.targetKind === ROUTE_TARGET_KIND2) {
-      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types80.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types81.EdgeType.CALLS };
     }
     return null;
   };
@@ -19122,21 +19806,21 @@ function mapInsightsToSignals(rows, observedAtIso) {
 
 // src/connectors/planetscale/resolve.ts
 init_cjs_shims();
-var import_types84 = require("@neat.is/types");
+var import_types85 = require("@neat.is/types");
 var PLANETSCALE_DATABASE_KIND = "planetscale-database";
 function createPlanetscaleResolveTarget(graph, config) {
   const databaseName = `${config.organization}/${config.database}`;
   return (signal, _ctx) => {
     if (signal.targetKind !== PLANETSCALE_SQL_TABLE_TARGET_KIND || !signal.targetName) return null;
-    const tableId = (0, import_types84.infraId)("sql-table", signal.targetName);
+    const tableId = (0, import_types85.infraId)("sql-table", signal.targetName);
     if (graph.hasNode(tableId)) {
-      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types84.EdgeType.CALLS };
+      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types85.EdgeType.CALLS };
     }
-    const providerId = (0, import_types84.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
+    const providerId = (0, import_types85.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
     return {
       targetNodeId: providerId,
       serviceName: config.serviceName,
-      edgeType: import_types84.EdgeType.CALLS,
+      edgeType: import_types85.EdgeType.CALLS,
       ensureInfraNode: { kind: PLANETSCALE_DATABASE_KIND, name: databaseName, provider: "planetscale" }
     };
   };
@@ -19401,7 +20085,7 @@ function mapBuildsToSignals(builds, serviceName) {
 
 // src/connectors/eas/resolve.ts
 init_cjs_shims();
-var import_types89 = require("@neat.is/types");
+var import_types90 = require("@neat.is/types");
 var NO_ENV2 = "unknown";
 var EAS_JSON_PHASES = /* @__PURE__ */ new Set(["READ_EAS_JSON"]);
 var APP_CONFIG_PHASES = /* @__PURE__ */ new Set([
@@ -19417,8 +20101,8 @@ function configBasenamesForPhase(phase) {
 function configNodeService(graph, configNodeId) {
   for (const edgeId of graph.inboundEdges(configNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types89.EdgeType.CONFIGURED_BY) continue;
-    const parsed = (0, import_types89.parseFileId)(edge.source);
+    if (edge.type !== import_types90.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types90.parseFileId)(edge.source);
     if (parsed) return parsed.service;
   }
   return null;
@@ -19429,7 +20113,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== import_types89.NodeType.ConfigNode) return;
+    if (node.type !== import_types90.NodeType.ConfigNode) return;
     if (typeof node.name !== "string" || !basenames.includes(node.name)) return;
     if (anyMatch === null) anyMatch = id;
     if (configNodeService(graph, id) === serviceName) scoped = id;
@@ -19446,13 +20130,13 @@ function createEasResolveTarget(graph) {
     if (basenames.length > 0) {
       const configNodeId = findConfigNode(graph, basenames, serviceName);
       if (configNodeId) {
-        return { targetNodeId: configNodeId, serviceName, edgeType: import_types89.EdgeType.CALLS };
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types90.EdgeType.CALLS };
       }
     }
     return {
       targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
       serviceName,
-      edgeType: import_types89.EdgeType.CALLS
+      edgeType: import_types90.EdgeType.CALLS
     };
   };
 }
@@ -20131,11 +20815,11 @@ function registerRoutes(scope, ctx) {
       const candidates = req.query.type.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       const parsed = [];
       for (const c of candidates) {
-        const r = import_types92.DivergenceTypeSchema.safeParse(c);
+        const r = import_types93.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types92.DivergenceTypeSchema.options
+            allowed: import_types93.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -20377,6 +21061,18 @@ function registerRoutes(scope, ctx) {
       matches: matches.slice(0, safeLimit)
     };
   });
+  scope.get("/graph/ask", async (req, reply) => {
+    const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    const question = (req.query.q ?? "").trim();
+    if (!question) return reply.code(400).send({ error: "query parameter `q` is required" });
+    const epath = errorsPathFor(proj);
+    const incidents = epath ? await readErrorEvents(epath) : [];
+    return askGraph(proj.graph, question, {
+      ...proj.searchIndex ? { searchIndex: proj.searchIndex } : {},
+      incidents
+    });
+  });
   scope.get(
     "/graph/diff",
     async (req, reply) => {
@@ -20477,7 +21173,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types92.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types93.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -20516,7 +21212,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
-    const parsed = import_types92.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types93.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",