@neat.is/core 0.9.3-dev.20260823 → 0.9.4

package/dist/neatd.js

@@ -2,11 +2,11 @@
 import {
   reconcileDaemonRecordSync,
   startDaemon
-} from "./chunk-WJGZYEUG.js";
+} from "./chunk-TGCWMMF6.js";
 import {
   listProjects,
   registryPath
-} from "./chunk-LRYPKC3B.js";
+} from "./chunk-IVVF37OU.js";
 import {
   BindAuthorityError,
   __require

package/dist/server.cjs

@@ -4706,6 +4706,64 @@ function latencyPercentiles(hist) {
   return { p50: round(quantile(hist, 0.5)), p95: round(quantile(hist, 0.95)) };
 }
 
+// src/stacktrace.ts
+init_cjs_shims();
+var FRAME_SHAPES = [
+  // `File "<path>", line <N>, in <func>` — the "most recent call last" shape.
+  { re: /File "([^"]+)", line (\d+)(?:, in (\S+))?/, file: 1, line: 2, fn: 3, deepest: "last" },
+  // `at <func> (<path>:<line>:<col>)` — named call frame, most recent first.
+  { re: /\bat\s+(.+?)\s+\((.+?):(\d+):\d+\)/, file: 2, line: 3, fn: 1, deepest: "first" },
+  // `at <path>:<line>:<col>` — anonymous call frame, most recent first.
+  { re: /\bat\s+(.+?):(\d+):\d+/, file: 1, line: 2, deepest: "first" },
+  // `at <qualified.method>(<File.ext>:<line>)` — JVM-style, most recent first.
+  { re: /\bat\s+(.+?)\((\S+\.\w+):(\d+)\)/, file: 2, line: 3, fn: 1, deepest: "first" }
+];
+var VENDOR_MARKERS = [
+  "node_modules",
+  // dependency root
+  "site-packages",
+  // installed-package root
+  "dist-packages",
+  // distro-packaged root
+  "node:"
+  // runtime-internal module scheme (a stdlib/runtime-root frame)
+];
+function matchFrame(line) {
+  for (const shape of FRAME_SHAPES) {
+    const m = shape.re.exec(line);
+    if (!m) continue;
+    const file = m[shape.file];
+    const lineNo = Number(m[shape.line]);
+    if (!file || !Number.isFinite(lineNo)) continue;
+    const fn = shape.fn !== void 0 ? m[shape.fn] : void 0;
+    return { frame: { file, line: lineNo, ...fn ? { fn } : {} }, deepest: shape.deepest };
+  }
+  return null;
+}
+function isApplicationFrame(file) {
+  if (file.startsWith("<")) return false;
+  const norm = file.split("\\").join("/");
+  for (const marker of VENDOR_MARKERS) {
+    if (norm.includes(marker)) return false;
+  }
+  return true;
+}
+function deepestApplicationFrame(stacktrace) {
+  if (!stacktrace) return null;
+  const appFrames = [];
+  for (const raw of stacktrace.split("\n")) {
+    const matched = matchFrame(raw);
+    if (!matched) continue;
+    if (!isApplicationFrame(matched.frame.file)) continue;
+    appFrames.push(matched);
+  }
+  if (appFrames.length === 0) return null;
+  const orientation = appFrames.some((f) => f.deepest === "last") ? "last" : "first";
+  const oriented = appFrames.filter((f) => f.deepest === orientation);
+  const chosen = orientation === "last" ? oriented[oriented.length - 1] : oriented[0];
+  return chosen ? chosen.frame : null;
+}
+
 // src/ingest.ts
 var HOUR_MS = 60 * 60 * 1e3;
 var DAY_MS = 24 * HOUR_MS;
@@ -5557,29 +5615,71 @@ async function appendConnectorIncident(errorsPath, input) {
   await import_node_fs9.promises.mkdir(import_node_path10.default.dirname(errorsPath), { recursive: true });
   await import_node_fs9.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
-function incidentAffectedNode(span, graph, scanPath) {
+function landIncidentCallSite(span, callSite, trusted, graph) {
+  const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
+  const canonicalService = serviceNodeName(graph, span) ?? span.service;
+  const recovered = !trusted;
+  if (graph) {
+    const fusedFileId = (0, import_types7.fileId)(canonicalService, relPath);
+    if (graph.hasNode(fusedFileId)) {
+      const node = landObservedSymbol(
+        graph,
+        fusedFileId,
+        canonicalService,
+        relPath,
+        { ...callSite, relPath },
+        false
+      );
+      return {
+        affectedNode: node,
+        ...recovered ? {
+          codeFilepath: relPath,
+          ...callSite.line !== void 0 ? { codeLineno: callSite.line } : {}
+        } : {}
+      };
+    }
+    if (recovered) return null;
+  }
+  return { affectedNode: (0, import_types7.fileId)(span.service, relPath) };
+}
+function serviceNodeName(graph, span) {
+  if (!graph) return void 0;
+  const sid = resolveFusedServiceId(graph, span.service, span.env);
+  if (!graph.hasNode(sid)) return void 0;
+  const node = graph.getNodeAttributes(sid);
+  return typeof node.name === "string" ? node.name : void 0;
+}
+function stacktraceCallSite(span, serviceNode, scanPath) {
+  const frame = deepestApplicationFrame(span.exception?.stacktrace);
+  if (!frame) return null;
+  const relPath = relPathForRuntimeFile(frame.file, serviceNode, scanPath);
+  if (!relPath) return null;
+  return { relPath, line: frame.line, ...frame.fn ? { fn: frame.fn } : {} };
+}
+function incidentLocus(span, graph, scanPath) {
   const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : (0, import_types7.serviceId)(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
   const callSite = callSiteFromSpan(span, serviceNode, scanPath);
   if (callSite) {
-    const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
-    const canonicalService = serviceNode && typeof serviceNode.name === "string" ? serviceNode.name : span.service;
-    if (graph) {
-      const fusedFileId = (0, import_types7.fileId)(canonicalService, relPath);
-      if (graph.hasNode(fusedFileId)) {
-        return landObservedSymbol(
-          graph,
-          fusedFileId,
-          canonicalService,
-          relPath,
-          { ...callSite, relPath },
-          false
-        );
-      }
+    const landed = landIncidentCallSite(span, callSite, true, graph);
+    if (landed) return landed;
+  } else {
+    const recovered = stacktraceCallSite(span, serviceNode, scanPath);
+    if (recovered) {
+      const landed = landIncidentCallSite(span, recovered, false, graph);
+      if (landed) return landed;
     }
-    return (0, import_types7.fileId)(span.service, relPath);
   }
-  return sid;
+  return { affectedNode: sid };
+}
+function incidentAffectedNode(span, graph, scanPath) {
+  return incidentLocus(span, graph, scanPath).affectedNode;
+}
+function withRecoveredCodeAttrs(attrs, locus) {
+  if (locus.codeFilepath === void 0) return attrs;
+  attrs[CODE_FILEPATH_ATTR] = locus.codeFilepath;
+  if (locus.codeLineno !== void 0) attrs[CODE_LINENO_ATTR] = locus.codeLineno;
+  return attrs;
 }
 function sanitizeAttributes(attrs) {
   const out = {};
@@ -5612,7 +5712,8 @@ async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp,
   await appendErrorEvent(ctx, ev);
 }
 async function recordExceptionIncident(ctx, span, ts) {
-  const attrs = sanitizeAttributes(span.attributes);
+  const locus = incidentLocus(span, ctx.graph, ctx.scanPath);
+  const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
   const ev = {
     id: `${span.traceId}:${span.spanId}`,
     timestamp: ts,
@@ -5623,7 +5724,7 @@ async function recordExceptionIncident(ctx, span, ts) {
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
-    affectedNode: incidentAffectedNode(span, ctx.graph, ctx.scanPath)
+    affectedNode: locus.affectedNode
   };
   await appendErrorEvent(ctx, ev);
 }
@@ -5926,7 +6027,8 @@ async function handleSpan(ctx, span) {
   if (span.statusCode === 2) {
     stitchTrace(ctx.graph, sourceId, ts);
     if (ctx.writeErrorEventInline !== false) {
-      const attrs = sanitizeAttributes(span.attributes);
+      const locus = incidentLocus(span, ctx.graph, ctx.scanPath);
+      const attrs = withRecoveredCodeAttrs(sanitizeAttributes(span.attributes), locus);
       const ev = {
         id: `${span.traceId}:${span.spanId}`,
         timestamp: ts,
@@ -5938,10 +6040,11 @@ async function handleSpan(ctx, span) {
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
         // Attribute to where the failure originated — the symbol / file / service
-        // the throwing span named (incidentAffectedNode, ADR-191) — the same
-        // source-based attribution the durable receiver write uses, not the
-        // outbound edge target this span happened to mint.
-        affectedNode: incidentAffectedNode(span, ctx.graph, ctx.scanPath)
+        // the throwing span named (incidentAffectedNode / ADR-191, extended to
+        // recover the locus from the stacktrace when the span stamped no code.*
+        // attrs, ADR-216) — the same source-based attribution the durable
+        // receiver write uses, not the outbound edge target this span minted.
+        affectedNode: locus.affectedNode
       };
       await appendErrorEvent(ctx, ev);
     }
@@ -6115,15 +6218,36 @@ function startStalenessLoop(graph, options = {}) {
     clearInterval(interval);
   };
 }
-async function readErrorEvents(errorsPath) {
+var INCIDENT_READ_MAX_BYTES = 32 * 1024 * 1024;
+var INCIDENT_READ_MAX_EVENTS = 5e3;
+async function readErrorFileTail(errorsPath, maxBytes) {
+  const handle = await import_node_fs9.promises.open(errorsPath, "r");
+  try {
+    const { size } = await handle.stat();
+    if (size <= maxBytes) {
+      return (await handle.readFile()).toString("utf8");
+    }
+    const buf = Buffer.alloc(maxBytes);
+    await handle.read(buf, 0, maxBytes, size - maxBytes);
+    const raw = buf.toString("utf8");
+    const firstNewline = raw.indexOf("\n");
+    return firstNewline === -1 ? "" : raw.slice(firstNewline + 1);
+  } finally {
+    await handle.close();
+  }
+}
+async function readErrorEvents(errorsPath, opts) {
+  let raw;
   try {
-    const raw = await import_node_fs9.promises.readFile(errorsPath, "utf8");
-    const events = raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
-    return dedupeIncidents(events);
+    raw = await readErrorFileTail(errorsPath, INCIDENT_READ_MAX_BYTES);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
   }
+  const events = raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
+  const deduped = dedupeIncidents(events);
+  const cap = opts?.limit !== void 0 && opts.limit > 0 ? Math.min(opts.limit, INCIDENT_READ_MAX_EVENTS) : INCIDENT_READ_MAX_EVENTS;
+  return deduped.length > cap ? deduped.slice(deduped.length - cap) : deduped;
 }
 function isSynthesizedHttpIncident(ev) {
   if (ev.exceptionType || ev.exceptionStacktrace) return false;
@@ -6883,6 +7007,47 @@ function classifyNode(ctx) {
 function isVictimSeed(ctx) {
   return ctx.errorsFromCallers > 0 && (ctx.stale || isSaturated(ctx)) && ctx.errorsEmittedHere <= ctx.errorsFromCallers;
 }
+var OUTBOUND_CONNECTION_FAILURE_PATTERNS = [
+  "name resolution",
+  "resolve host",
+  "getaddrinfo",
+  "enotfound",
+  "connection refused",
+  "econnrefused",
+  "connection reset",
+  "econnreset",
+  "able to connect",
+  "failed to connect",
+  "cannot connect",
+  "could not connect",
+  "unable to connect",
+  "connection timed out",
+  "etimedout",
+  "no route to host",
+  "host unreachable",
+  "network is unreachable",
+  "connection closed"
+];
+function incidentTextIndicatesOutboundFailure(ev) {
+  const haystack = [ev.errorMessage, ev.errorType, ev.exceptionType, ev.exceptionStacktrace].filter((s) => typeof s === "string").join(" ").toLowerCase();
+  return OUTBOUND_CONNECTION_FAILURE_PATTERNS.some((p) => haystack.includes(p));
+}
+function hasFailingOutbound(graph, nodeId, seedSource, incidents) {
+  for (const n of nodeScope(graph, nodeId)) {
+    if (!graph.hasNode(n)) continue;
+    for (const edgeId of graph.outboundEdges(n)) {
+      const e = graph.getEdgeAttributes(edgeId);
+      if (e.type === import_types8.EdgeType.CONTAINS) continue;
+      if ((e.signal?.errorCount ?? 0) > 0) return true;
+    }
+  }
+  if (seedSource === "incident" && incidents) {
+    for (const ev of incidents) {
+      if (incidentMatchesNode(ev, nodeId) && incidentTextIndicatesOutboundFailure(ev)) return true;
+    }
+  }
+  return false;
+}
 function grainOf(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return "unknown";
   const t = graph.getNodeAttributes(nodeId).type;
@@ -7046,7 +7211,8 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
   const candidates = [];
   const deadEndOnSymptom = tagged.source === "incident" && seedNode === errorNodeId && legacy.traversalPath.length === 1;
   const staleChain = deadEndOnSymptom && !(seedCtx && isVictimSeed(seedCtx)) ? followStaleCallChain(graph, errorNodeId, ROOT_CAUSE_MAX_DEPTH) : null;
-  if (seedCtx && isVictimSeed(seedCtx)) {
+  const seedFailsOutbound = seedCtx !== null && hasFailingOutbound(graph, seedNode, tagged.source, incidents);
+  if (seedCtx && isVictimSeed(seedCtx) && !seedFailsOutbound) {
     const origin = findLoadOrigin(graph, errorNodeId, incidents, now);
     const staleNote = seedCtx.stale ? "; it has gone STALE under load" : "";
     const satNote = isSaturated(seedCtx) ? `; its inbound p95 ${Math.round(seedCtx.latencyP95Ms)}ms is saturated` : "";
@@ -7396,6 +7562,120 @@ function detectColumnDrift(node) {
   }
   return out;
 }
+var SYMBOL_MISMATCH_PATTERNS = [
+  {
+    // "'ListProductsResponse' object has no attribute 'products_list'" and kin.
+    kind: "missing-attribute",
+    patterns: [/\bhas no attribute\b[\s:=]*['"`]?([A-Za-z_$][\w$]*)['"`]?/i]
+  },
+  {
+    // "object has no field 'X'", "no such field X", "unknown field X".
+    kind: "missing-field",
+    patterns: [
+      /\b(?:has no field|no such field|unknown field)\b(?:\s+named)?[\s:=]*['"`]?([A-Za-z_$][\w$.]*)['"`]?/i
+    ]
+  },
+  {
+    // "has no property X", "no property named X".
+    kind: "missing-property",
+    patterns: [
+      /\b(?:has no property|no property named)\b[\s:=]*['"`]?([A-Za-z_$][\w$]*)['"`]?/i
+    ]
+  },
+  {
+    // "no such column: X", "unknown column 'X'", "column X does not exist".
+    kind: "missing-column",
+    patterns: [
+      /\bno such column\b[\s:=]*['"`]?([\w$.]+)['"`]?/i,
+      /\bunknown column\b[\s:=]*['"`]?([\w$.]+)['"`]?/i,
+      /\bcolumn\b[\s:=]*['"`]?([\w$.]+)['"`]?\s+does not exist/i
+    ]
+  },
+  {
+    // "undefined method `foo' for X" — kept to the unambiguous form so a generic
+    // "method not found" (an unimplemented RPC — an edge/route gap, not a symbol
+    // mismatch) does not get miscategorised here.
+    kind: "undefined-method",
+    patterns: [/\bundefined method\b\s*[`'"]?([\w$?!]+)/i]
+  }
+];
+function classifySymbolMismatch(message) {
+  for (const entry of SYMBOL_MISMATCH_PATTERNS) {
+    for (const re of entry.patterns) {
+      const m = re.exec(message);
+      if (m) {
+        const captured = m[1];
+        return captured ? { kind: entry.kind, symbol: captured } : { kind: entry.kind };
+      }
+    }
+  }
+  return null;
+}
+function symbolLocus(graph, ev) {
+  const attrs = ev.attributes ?? {};
+  const filepath = codeFilepathOf(attrs);
+  const lineno = codeLinenoOf(attrs);
+  const location = filepath ? `${filepath}${lineno !== void 0 ? `:${lineno}` : ""}` : void 0;
+  const affected = ev.affectedNode;
+  const affectedInGraph = affected.length > 0 && graph.hasNode(affected);
+  const affectedIsCode = affectedInGraph && ((0, import_types9.parseSymbolId)(affected) !== null || (0, import_types9.parseFileId)(affected) !== null);
+  if (affectedIsCode) return { node: affected, ...location ? { location } : {} };
+  if (!location) return null;
+  if (affectedInGraph) return { node: affected, location };
+  const svc = (0, import_types9.serviceId)(ev.service);
+  if (graph.hasNode(svc)) return { node: svc, location };
+  return null;
+}
+var SYMBOL_MISMATCH_CONFIDENCE = 0.6;
+function detectSymbolMismatches(graph, incidents) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const ev of incidents) {
+    const classified = classifySymbolMismatch(ev.errorMessage);
+    if (!classified) continue;
+    const locus = symbolLocus(graph, ev);
+    if (!locus) continue;
+    const key = `${locus.node}|${classified.kind}|${classified.symbol ?? ""}`;
+    const existing = groups.get(key);
+    if (!existing) {
+      groups.set(key, {
+        node: locus.node,
+        kind: classified.kind,
+        ...classified.symbol ? { symbol: classified.symbol } : {},
+        ...locus.location ? { location: locus.location } : {},
+        latest: ev,
+        count: 1
+      });
+    } else {
+      existing.count += 1;
+      if (ev.timestamp.localeCompare(existing.latest.timestamp) > 0) {
+        existing.latest = ev;
+        if (locus.location) existing.location = locus.location;
+      }
+    }
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    const member = g.symbol ? `\`${g.symbol}\`` : "a member";
+    const where = g.location ? ` at ${g.location}` : "";
+    const times = g.count > 1 ? ` (${g.count} recorded incidents)` : " (1 recorded incident)";
+    out.push({
+      type: "observed-symbol-mismatch",
+      source: g.node,
+      target: g.node,
+      mismatchKind: g.kind,
+      ...g.symbol ? { symbol: g.symbol } : {},
+      ...g.location ? { location: g.location } : {},
+      provenance: import_types9.Provenance.INFERRED,
+      incidentId: g.latest.id,
+      errorMessage: g.latest.errorMessage,
+      incidentCount: g.count,
+      confidence: SYMBOL_MISMATCH_CONFIDENCE,
+      reason: `Code${where} declares access to ${member} the runtime object does not have \u2014 ${g.latest.service} raised "${g.latest.errorMessage}"${times}. The declared access (EXTRACTED) and the runtime shape (OBSERVED) disagree at symbol grain.`,
+      recommendation: "Reconcile the declared access with the runtime shape: a field, attribute, method, or column was renamed, removed, or never existed on the object this code reaches. Update the code to the current shape, or restore the member."
+    });
+  }
+  return out;
+}
 function involvesNode(d, nodeId) {
   return d.source === nodeId || d.target === nodeId;
 }
@@ -7481,6 +7761,9 @@ function computeDivergences(graph, opts = {}) {
       for (const d of detectColumnDrift(n)) all.push(d);
     }
   });
+  if (opts.incidents && opts.incidents.length > 0) {
+    for (const d of detectSymbolMismatches(graph, opts.incidents)) all.push(d);
+  }
   const reconciled = suppressHostMismatchHalves(all);
   const dampened = dampenDeadCodeProbes(graph, buckets2, reconciled);
   let filtered = dampened;
@@ -7501,7 +7784,12 @@ function computeDivergences(graph, opts = {}) {
     "missing-observed": 1,
     "version-mismatch": 2,
     "host-mismatch": 3,
-    "compat-violation": 4
+    "compat-violation": 4,
+    // Symbol/field-grain (ADR-215) rides the confidence sort like every other
+    // type; this only breaks a confidence tie, and it orders last so a same-
+    // confidence edge finding leads. In practice it carries the INFERRED grade
+    // (0.6), so it sits below the high-confidence edge divergences already.
+    "observed-symbol-mismatch": 5
   };
   filtered.sort((a, b) => {
     if (b.confidence !== a.confidence) return b.confidence - a.confidence;
@@ -7512,7 +7800,10 @@ function computeDivergences(graph, opts = {}) {
     if (a.target !== b.target) return a.target.localeCompare(b.target);
     const ac = "column" in a && a.column ? a.column : "";
     const bc = "column" in b && b.column ? b.column : "";
-    return ac.localeCompare(bc);
+    if (ac !== bc) return ac.localeCompare(bc);
+    const asym = "symbol" in a && a.symbol ? a.symbol : "";
+    const bsym = "symbol" in b && b.symbol ? b.symbol : "";
+    return asym.localeCompare(bsym);
   });
   return import_types9.DivergenceResultSchema.parse({
     divergences: filtered,
@@ -16692,10 +16983,15 @@ 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}`;
   }
+  if (d.type === "observed-symbol-mismatch") {
+    const at = d.location ? ` at ${d.location}` : "";
+    const member = d.symbol ? ` ${d.symbol}` : "";
+    return `[${d.type}] ${d.source}${member}${at} \u2014 ${d.reason}`;
+  }
   return `[${d.type}] ${d.source} \u2192 ${d.target} \u2014 ${d.reason}`;
 }
-function buildDivergenceSection(graph, node) {
-  const result = computeDivergences(graph, { node });
+function buildDivergenceSection(graph, node, incidents) {
+  const result = computeDivergences(graph, { node, ...incidents ? { incidents } : {} });
   if (result.totalAffected === 0) return null;
   const facts = result.divergences.slice(0, MAX_FACTS_PER_SECTION).map((d) => ({
     text: divergenceLine(d),
@@ -16708,8 +17004,8 @@ function buildDivergenceSection(graph, node) {
     facts
   };
 }
-function buildGlobalDivergenceSection(graph) {
-  const result = computeDivergences(graph);
+function buildGlobalDivergenceSection(graph, incidents) {
+  const result = computeDivergences(graph, incidents ? { incidents } : {});
   if (result.totalAffected === 0) {
     return {
       heading: "Divergences (EXTRACTED vs OBSERVED)",
@@ -16807,7 +17103,7 @@ function buildOverviewSections(graph, incidents) {
       }))
     });
   }
-  const div = computeDivergences(graph);
+  const div = computeDivergences(graph, incidents ? { incidents } : {});
   sections.push({
     heading: "Divergences",
     facts: [
@@ -16821,7 +17117,7 @@ function buildOverviewSections(graph, incidents) {
 function buildGlobalSections(intent, graph, incidents) {
   switch (intent) {
     case "divergence":
-      return [buildGlobalDivergenceSection(graph)];
+      return [buildGlobalDivergenceSection(graph, incidents)];
     case "incidents":
       return [buildGlobalIncidentsSection(incidents)];
     case "overview":
@@ -16852,7 +17148,7 @@ function buildSection(kind, graph, node, incidents, now) {
     case "incidents":
       return buildIncidentsSection(node, incidents);
     case "divergence":
-      return buildDivergenceSection(graph, node);
+      return buildDivergenceSection(graph, node, incidents);
   }
 }
 function summarizeGlobal(intent, sections) {
@@ -20657,6 +20953,8 @@ function buildRegistration(entry, graph, env = process.env) {
 }
 
 // src/api.ts
+var INCIDENT_LIST_DEFAULT_LIMIT = 50;
+var INCIDENT_LIST_MAX_LIMIT = 200;
 function serializeGraph(graph) {
   const nodes = [];
   graph.forEachNode((_id, attrs) => {
@@ -20836,10 +21134,13 @@ function registerRoutes(scope, ctx) {
       }
       minConfidence = n;
     }
+    const epath = errorsPathFor(proj);
+    const incidents = epath ? await readErrorEvents(epath) : [];
     return computeDivergences(proj.graph, {
       ...typeFilter ? { type: typeFilter } : {},
       ...minConfidence !== void 0 ? { minConfidence } : {},
-      ...req.query.node ? { node: req.query.node } : {}
+      ...req.query.node ? { node: req.query.node } : {},
+      incidents
     });
   });
   scope.get("/incidents", async (req, reply) => {
@@ -20849,10 +21150,11 @@ function registerRoutes(scope, ctx) {
     if (!epath) return { count: 0, total: 0, events: [] };
     const events = await readErrorEvents(epath);
     const total = events.length;
-    const limit = req.query.limit ? Number(req.query.limit) : 50;
-    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(limit, 200) : 50;
+    const limit = req.query.limit ? Number(req.query.limit) : INCIDENT_LIST_DEFAULT_LIMIT;
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(limit, INCIDENT_LIST_MAX_LIMIT) : INCIDENT_LIST_DEFAULT_LIMIT;
     const sliced = events.slice(0, safeLimit);
-    return { count: sliced.length, total, events: sliced };
+    const omitted = total - sliced.length;
+    return { count: sliced.length, total, events: sliced, ...omitted > 0 ? { omitted } : {} };
   });
   scope.get("/stale-events", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
@@ -20961,16 +21263,20 @@ function registerRoutes(scope, ctx) {
     const filtered = events.filter(
       (e) => e.affectedNode === nodeId || e.service === nodeId.replace(/^service:/, "")
     );
-    return { count: filtered.length, total: filtered.length, events: filtered };
+    const total = filtered.length;
+    const limit = req.query.limit ? Number(req.query.limit) : INCIDENT_LIST_DEFAULT_LIMIT;
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(limit, INCIDENT_LIST_MAX_LIMIT) : INCIDENT_LIST_DEFAULT_LIMIT;
+    const recent = [...filtered].sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? "")).slice(0, safeLimit);
+    const omitted = total - recent.length;
+    return {
+      count: recent.length,
+      total,
+      events: recent,
+      ...omitted > 0 ? { omitted } : {}
+    };
   };
-  scope.get(
-    "/incidents/:nodeId",
-    incidentHistoryHandler
-  );
-  scope.get(
-    "/graph/incident-history/:nodeId",
-    incidentHistoryHandler
-  );
+  scope.get("/incidents/:nodeId", incidentHistoryHandler);
+  scope.get("/graph/incident-history/:nodeId", incidentHistoryHandler);
   scope.get("/graph/root-cause/:nodeId", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;