@neat.is/core 0.9.8-dev.20260828 → 0.9.8

package/dist/neatd.cjs

@@ -6309,11 +6309,25 @@ function upsertInferredEdge(graph, type, source, target, ts) {
   };
   graph.addEdgeWithKey(id, source, target, edge);
 }
+function emitIncidentEvent(project, ev) {
+  emitNeatEvent({
+    type: "incident",
+    project,
+    payload: {
+      incidentId: ev.id,
+      affectedNode: ev.affectedNode,
+      service: ev.service,
+      incidentKind: (0, import_types8.incidentKindOf)(ev),
+      at: ev.timestamp
+    }
+  });
+}
 async function appendErrorEvent(ctx, ev) {
   await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(ctx.errorsPath), { recursive: true });
   await import_node_fs7.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  emitIncidentEvent(ctx.project ?? DEFAULT_PROJECT, ev);
 }
-async function appendConnectorIncident(errorsPath, input) {
+async function appendConnectorIncident(errorsPath, input, project) {
   const ev = {
     id: input.id,
     timestamp: input.timestamp,
@@ -6327,6 +6341,7 @@ async function appendConnectorIncident(errorsPath, input) {
   };
   await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(errorsPath), { recursive: true });
   await import_node_fs7.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  if (project) emitIncidentEvent(project, ev);
 }
 function landIncidentCallSite(span, callSite, trusted, graph) {
   const relPath = graph ? reconcileObservedRelPath(graph, span.service, callSite.relPath) : callSite.relPath;
@@ -6420,12 +6435,13 @@ function buildErrorEventForReceiver(span, graph, scanPath) {
     affectedNode: locus.affectedNode
   };
 }
-function makeErrorSpanWriter(errorsPath, graph, scanPath) {
+function makeErrorSpanWriter(errorsPath, graph, scanPath, project = DEFAULT_PROJECT) {
   return async (span) => {
     const ev = buildErrorEventForReceiver(span, graph, scanPath);
     if (!ev) return;
     await import_node_fs7.promises.mkdir(import_node_path8.default.dirname(errorsPath), { recursive: true });
     await import_node_fs7.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    emitIncidentEvent(project, ev);
   };
 }
 async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp, statusCode, count, firstTimestamp) {
@@ -16132,7 +16148,7 @@ var Projects = class {
 init_cjs_shims();
 var import_fastify2 = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types97 = require("@neat.is/types");
+var import_types98 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -17174,9 +17190,128 @@ function queryLogEntries(opts) {
   return merged;
 }
 
-// src/ask.ts
+// src/goodybag.ts
 init_cjs_shims();
 var import_types59 = require("@neat.is/types");
+var CODE_FILEPATH_ATTR2 = "code.filepath";
+var CODE_LINENO_ATTR2 = "code.lineno";
+var BLAST_NEAREST_LIMIT = 5;
+function grainOf2(graph, nodeId) {
+  if (graph.hasNode(nodeId)) {
+    const t = graph.getNodeAttributes(nodeId).type;
+    if (typeof t === "string" && t.length > 0) {
+      return (t.endsWith("Node") ? t.slice(0, -4) : t).toLowerCase();
+    }
+  }
+  const colon = nodeId.indexOf(":");
+  return colon > 0 ? nodeId.slice(0, colon) : "unknown";
+}
+function locusOf(graph, ev) {
+  const file = ev.attributes?.[CODE_FILEPATH_ATTR2];
+  if (typeof file !== "string" || file.length === 0) return null;
+  const rawLine = ev.attributes?.[CODE_LINENO_ATTR2];
+  const line = typeof rawLine === "number" ? rawLine : Number(rawLine);
+  const node = graph.hasNode(ev.affectedNode) ? graph.getNodeAttributes(ev.affectedNode) : void 0;
+  return {
+    file,
+    ...Number.isFinite(line) ? { lineStart: line, lineEnd: line } : {},
+    ...node?.name ? { symbol: node.name } : {},
+    service: node?.service ?? ev.service,
+    provenance: import_types59.Provenance.OBSERVED
+  };
+}
+function divergenceSummary(d) {
+  const column = "column" in d && d.column ? `.${d.column}` : "";
+  const label = "table" in d && d.table ? `${d.table}${column}` : `${d.source} \u2192 ${d.target}`;
+  return label;
+}
+function baseName(p) {
+  const parts = p.split(/[\\/]/);
+  return parts[parts.length - 1] || p;
+}
+function shortLabel(graph, nodeId) {
+  if (graph.hasNode(nodeId)) {
+    const name = graph.getNodeAttributes(nodeId).name;
+    if (typeof name === "string" && name.length > 0) return name;
+  }
+  const afterHash = nodeId.includes("#") ? nodeId.slice(nodeId.lastIndexOf("#") + 1) : nodeId;
+  return afterHash.includes(":") ? afterHash.slice(afterHash.lastIndexOf(":") + 1) : afterHash;
+}
+function renderHeadline(graph, ev, locus, causeNode) {
+  const what = ev.exceptionType ? `raised ${ev.exceptionType}` : ev.errorMessage || "failed";
+  const cause = causeNode && causeNode !== ev.affectedNode ? ` \u2192 root cause ${shortLabel(graph, causeNode)}` : "";
+  if (locus) {
+    const base = baseName(locus.file);
+    const lines = locus.lineStart != null ? locus.lineEnd && locus.lineEnd !== locus.lineStart ? `LINES ${locus.lineStart}-${locus.lineEnd}` : `LINE ${locus.lineStart}` : "";
+    const symbol = locus.symbol ?? (grainOf2(graph, ev.affectedNode) === "symbol" ? shortLabel(graph, ev.affectedNode) : void 0);
+    const subject = symbol ? `SYMBOL ${symbol}` : `FILE ${base}`;
+    const at = symbol ? `${lines ? `${lines} in ` : ""}${base}` : lines;
+    const where = at ? ` at ${at}` : "";
+    return `${subject}${where} (SERVICE ${ev.service}) ${what} at ${ev.timestamp}${cause}`;
+  }
+  return `SERVICE ${ev.service} ${what} at ${ev.timestamp}${cause}`;
+}
+function buildIncidentCard(graph, errorEvent, incidents, policies) {
+  const affected = errorEvent.affectedNode;
+  const locus = locusOf(graph, errorEvent);
+  const inGraph = graph.hasNode(affected);
+  const rc = inGraph ? getRootCause(graph, affected, errorEvent, incidents) : null;
+  let rootCause = null;
+  if (rc) {
+    const provs = rc.edgeProvenances ?? [];
+    const chain = (rc.traversalPath ?? []).map((node, i) => ({
+      node,
+      grain: grainOf2(graph, node),
+      provenance: provs[i] ?? provs[provs.length - 1] ?? import_types59.Provenance.INFERRED
+    }));
+    rootCause = {
+      node: rc.rootCauseNode,
+      ...rc.candidates?.[0]?.classification ? { classification: rc.candidates[0].classification } : {},
+      reason: rc.rootCauseReason,
+      confidence: rc.confidence,
+      fix: rc.fixRecommendation ?? null,
+      chain
+    };
+  }
+  const blast = inGraph ? getBlastRadius(graph, affected) : { origin: affected, affectedNodes: [], totalAffected: 0 };
+  const nearest = [...blast.affectedNodes].sort((a, b) => a.distance - b.distance).slice(0, BLAST_NEAREST_LIMIT).map((n) => ({ node: n.nodeId, distance: n.distance, provenance: n.edgeProvenance }));
+  const applicable = inGraph ? selectApplicablePolicies(graph, policies, affected) : [];
+  const policyCards = applicable.map((p) => ({
+    policyName: p.policyName,
+    severity: p.severity,
+    message: p.reason
+  }));
+  const divergences = inGraph ? computeDivergences(graph, { node: affected, incidents }).divergences.map((d) => ({
+    type: d.type,
+    summary: divergenceSummary(d)
+  })) : [];
+  const card = {
+    kind: "incident",
+    id: errorEvent.id,
+    at: errorEvent.timestamp,
+    incidentKind: (0, import_types59.incidentKindOf)(errorEvent),
+    service: errorEvent.service,
+    affectedNode: affected,
+    message: errorEvent.errorMessage,
+    ...errorEvent.exceptionType ? { exceptionType: errorEvent.exceptionType } : {},
+    ...errorEvent.httpStatusCode !== void 0 ? { httpStatusCode: errorEvent.httpStatusCode } : {},
+    ...errorEvent.incidentCount !== void 0 ? { count: errorEvent.incidentCount } : {},
+    ...errorEvent.firstTimestamp && errorEvent.lastTimestamp ? { window: { first: errorEvent.firstTimestamp, last: errorEvent.lastTimestamp } } : {},
+    ...errorEvent.traceId ? { traceId: errorEvent.traceId } : {},
+    ...errorEvent.spanId ? { spanId: errorEvent.spanId } : {},
+    locus,
+    rootCause,
+    ...nearest.length > 0 ? { blastRadius: { totalAffected: blast.totalAffected, nearest } } : {},
+    ...policyCards.length > 0 ? { policies: policyCards } : {},
+    ...divergences.length > 0 ? { divergence: divergences } : {},
+    headline: renderHeadline(graph, errorEvent, locus, rootCause?.node ?? null)
+  };
+  return import_types59.IncidentCardSchema.parse(card);
+}
+
+// src/ask.ts
+init_cjs_shims();
+var import_types60 = require("@neat.is/types");
 var DEFAULT_MAX_NODES = 3;
 var MAX_FACTS_PER_SECTION = 6;
 var INTENT_RULES = [
@@ -17404,7 +17539,7 @@ async function resolveEntities(graph, question, searchIndex, maxNodes) {
   };
   graph.forEachNode((id, attrs) => {
     const node = attrs;
-    if (node.type === import_types59.NodeType.FrontierNode) return;
+    if (node.type === import_types60.NodeType.FrontierNode) return;
     const name = nodeName(node);
     const body = idBody(id);
     const labelTokens = /* @__PURE__ */ new Set([...tokens(body), ...tokens(name)]);
@@ -17423,7 +17558,7 @@ async function resolveEntities(graph, question, searchIndex, maxNodes) {
       const res = await searchIndex.search(question, 10);
       if (res.provider !== "substring") {
         for (const m of res.matches) {
-          if (m.node.type === import_types59.NodeType.FrontierNode) continue;
+          if (m.node.type === import_types60.NodeType.FrontierNode) continue;
           const already = best.get(m.node.id);
           if (!already && m.score < EMBED_MIN_SCORE) continue;
           consider({
@@ -17461,7 +17596,7 @@ function edgeSignalNote(e) {
 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_types59.Provenance.OBSERVED;
+  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? import_types60.Provenance.OBSERVED;
   const facts = [
     {
       text: `Root cause: ${result.rootCauseNode} \u2014 ${result.rootCauseReason}`,
@@ -17511,7 +17646,7 @@ function buildObservedSection(graph, node) {
     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_types59.Provenance.OBSERVED
+        provenance: import_types60.Provenance.OBSERVED
       });
     } else {
       return null;
@@ -17539,7 +17674,7 @@ function buildIncidentsSection(node, incidents) {
   const facts = ordered.map((ev) => ({
     text: `${ev.timestamp} \u2014 ${ev.service}: ${ev.errorMessage}`,
     // ErrorEvents are observation records — OBSERVED by definition.
-    provenance: import_types59.Provenance.OBSERVED
+    provenance: import_types60.Provenance.OBSERVED
   }));
   return { heading: `Recent incidents (OBSERVED) \u2014 ${relevant.length} recorded`, facts };
 }
@@ -17599,7 +17734,7 @@ function buildGlobalIncidentsSection(incidents) {
   }
   const byKey = /* @__PURE__ */ new Map();
   for (const ev of incidents) {
-    const key = ev.affectedNode || (0, import_types59.serviceId)(ev.service);
+    const key = ev.affectedNode || (0, import_types60.serviceId)(ev.service);
     const cur = byKey.get(key);
     if (!cur) {
       byKey.set(key, { key, count: 1, latest: ev.timestamp, sampleMsg: ev.errorMessage });
@@ -17614,7 +17749,7 @@ function buildGlobalIncidentsSection(incidents) {
   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_types59.Provenance.OBSERVED
+    provenance: import_types60.Provenance.OBSERVED
   }));
   return {
     heading: `Incidents across the system \u2014 ${incidents.length} recorded`,
@@ -17627,7 +17762,7 @@ function buildOverviewSections(graph, incidents) {
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
     nodeByType.set(node.type, (nodeByType.get(node.type) ?? 0) + 1);
-    if (node.type === import_types59.NodeType.ServiceNode) services.push(node.id);
+    if (node.type === import_types60.NodeType.ServiceNode) services.push(node.id);
   });
   const edgeByProv = /* @__PURE__ */ new Map();
   graph.forEachEdge((_id, attrs) => {
@@ -17639,10 +17774,10 @@ function buildOverviewSections(graph, incidents) {
   const shapeFacts = [
     { text: `${graph.order} nodes, ${graph.size} edges` },
     {
-      text: `${count(import_types59.NodeType.ServiceNode)} services, ${count(import_types59.NodeType.FileNode)} files, ${count(import_types59.NodeType.SymbolNode)} symbols, ${count(import_types59.NodeType.DatabaseNode)} databases`
+      text: `${count(import_types60.NodeType.ServiceNode)} services, ${count(import_types60.NodeType.FileNode)} files, ${count(import_types60.NodeType.SymbolNode)} symbols, ${count(import_types60.NodeType.DatabaseNode)} databases`
     }
   ];
-  for (const p of [import_types59.Provenance.EXTRACTED, import_types59.Provenance.OBSERVED, import_types59.Provenance.INFERRED, import_types59.Provenance.STALE]) {
+  for (const p of [import_types60.Provenance.EXTRACTED, import_types60.Provenance.OBSERVED, import_types60.Provenance.INFERRED, import_types60.Provenance.STALE]) {
     const n = edgeByProv.get(p) ?? 0;
     if (n > 0) shapeFacts.push({ text: `${n} ${p} edge${n === 1 ? "" : "s"}`, provenance: p });
   }
@@ -17659,7 +17794,7 @@ function buildOverviewSections(graph, incidents) {
   if (incidents && incidents.length > 0) {
     const incCount = /* @__PURE__ */ new Map();
     for (const ev of incidents) {
-      const key = ev.affectedNode || (0, import_types59.serviceId)(ev.service);
+      const key = ev.affectedNode || (0, import_types60.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);
@@ -17667,7 +17802,7 @@ function buildOverviewSections(graph, incidents) {
       heading: `Nodes with incidents \u2014 ${incidents.length} recorded`,
       facts: top.map(([k, n]) => ({
         text: `${k} \u2014 ${n} incident${n === 1 ? "" : "s"}`,
-        provenance: import_types59.Provenance.OBSERVED
+        provenance: import_types60.Provenance.OBSERVED
       }))
     });
   }
@@ -17803,7 +17938,7 @@ async function askGraph(graph, question, opts = {}) {
   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_types59.AskResultSchema.parse({
+  return import_types60.AskResultSchema.parse({
     question,
     intent,
     matched,
@@ -17898,7 +18033,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_types60 = require("@neat.is/types");
+var import_types61 = require("@neat.is/types");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
@@ -18100,10 +18235,10 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types60.RegistryFileSchema.parse(parsed);
+  return import_types61.RegistryFileSchema.parse(parsed);
 }
 async function writeRegistry(reg) {
-  const validated = import_types60.RegistryFileSchema.parse(reg);
+  const validated = import_types61.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
 async function getProject(name) {
@@ -18454,15 +18589,15 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 
 // src/connectors/index.ts
 init_cjs_shims();
-var import_types61 = require("@neat.is/types");
+var import_types62 = 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_types61.Provenance.EXTRACTED) continue;
-    const parsed = (0, import_types61.parseFileId)(edge.source);
+    if (edge.provenance !== import_types62.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types62.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;
@@ -18473,7 +18608,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_types61.NodeType.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== import_types62.NodeType.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -18503,7 +18638,7 @@ async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
         errorMessage: signal.incident.errorMessage,
         ...signal.incident.attributes ? { attributes: signal.incident.attributes } : {},
         affectedNode: resolved.targetNodeId
-      });
+      }, ctx.project);
       continue;
     }
     if (resolved.ensureInfraNode) {
@@ -19085,23 +19220,23 @@ async function fetchPgStatStatements(connectionString, limit = DEFAULT_STATEMENT
 
 // src/connectors/supabase/resolve.ts
 init_cjs_shims();
-var import_types63 = require("@neat.is/types");
+var import_types64 = 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_types63.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
+    const subResourceId = (0, import_types64.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
     if (graph.hasNode(subResourceId)) {
-      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types63.EdgeType.CALLS };
+      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types64.EdgeType.CALLS };
     }
-    const bareResourceId = (0, import_types63.infraId)(signal.targetKind, signal.targetName);
+    const bareResourceId = (0, import_types64.infraId)(signal.targetKind, signal.targetName);
     if (graph.hasNode(bareResourceId)) {
-      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types63.EdgeType.CALLS };
+      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types64.EdgeType.CALLS };
     }
-    const projectLevelId = (0, import_types63.infraId)("supabase", config.nodeRef);
+    const projectLevelId = (0, import_types64.infraId)("supabase", config.nodeRef);
     if (graph.hasNode(projectLevelId)) {
-      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types63.EdgeType.CALLS };
+      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types64.EdgeType.CALLS };
     }
     return null;
   };
@@ -19194,7 +19329,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 
 // src/connectors/railway/index.ts
 init_cjs_shims();
-var import_types67 = require("@neat.is/types");
+var import_types68 = require("@neat.is/types");
 
 // src/connectors/railway/client.ts
 init_cjs_shims();
@@ -19345,7 +19480,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   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;
     out.push({
@@ -19449,12 +19584,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_types67.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types68.EdgeType.CALLS };
     }
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: (0, import_types67.serviceId)(peerName), serviceName, edgeType: import_types67.EdgeType.CONNECTS_TO };
+      return { targetNodeId: (0, import_types68.serviceId)(peerName), serviceName, edgeType: import_types68.EdgeType.CONNECTS_TO };
     }
     return null;
   };
@@ -19642,7 +19777,7 @@ function mapLogEntriesToSignals(entries) {
 
 // src/connectors/firebase/resolve.ts
 init_cjs_shims();
-var import_types68 = require("@neat.is/types");
+var import_types69 = require("@neat.is/types");
 function neatServiceNameFor(resourceType, resourceName, serviceMap) {
   switch (resourceType) {
     case "cloud_function":
@@ -19657,7 +19792,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types68.NodeType.RouteNode) return;
+    if (node.type !== import_types69.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -19689,7 +19824,7 @@ function createFirebaseResolveTarget(graph, serviceMap) {
     return {
       targetNodeId: match.routeNodeId,
       serviceName,
-      edgeType: import_types68.EdgeType.CALLS
+      edgeType: import_types69.EdgeType.CALLS
     };
   };
 }
@@ -19716,7 +19851,7 @@ init_cjs_shims();
 
 // src/connectors/cloudflare/connector.ts
 init_cjs_shims();
-var import_types70 = require("@neat.is/types");
+var import_types71 = require("@neat.is/types");
 
 // src/connectors/cloudflare/client.ts
 init_cjs_shims();
@@ -19880,7 +20015,7 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === import_types70.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === import_types71.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
@@ -19892,7 +20027,7 @@ function findMatchingRouteNode(graph, serviceName, method, path78) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types70.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types71.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;
@@ -19911,11 +20046,11 @@ function createCloudflareResolveTarget(config, graph) {
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
-      const wholeFileId = (0, import_types70.fileId)(mapping.service, mapping.entryFile);
+      const wholeFileId = (0, import_types71.fileId)(mapping.service, mapping.entryFile);
       return {
         targetNodeId: resolveRouteGrain(mapping.service, wholeFileId),
         serviceName: mapping.service,
-        edgeType: import_types70.EdgeType.CALLS
+        edgeType: import_types71.EdgeType.CALLS
       };
     }
     const taggedFileId = findTaggedWorkerFileNode(graph, scriptName);
@@ -19924,13 +20059,13 @@ function createCloudflareResolveTarget(config, graph) {
       return {
         targetNodeId: resolveRouteGrain(fileNode.service, taggedFileId),
         serviceName: fileNode.service,
-        edgeType: import_types70.EdgeType.CALLS
+        edgeType: import_types71.EdgeType.CALLS
       };
     }
     return {
-      targetNodeId: (0, import_types70.infraId)("cloudflare-worker", scriptName),
+      targetNodeId: (0, import_types71.infraId)("cloudflare-worker", scriptName),
       serviceName: scriptName,
-      edgeType: import_types70.EdgeType.CALLS,
+      edgeType: import_types71.EdgeType.CALLS,
       ensureInfraNode: { kind: "cloudflare-worker", name: scriptName, provider: "cloudflare" }
     };
   };
@@ -20126,14 +20261,14 @@ function diffNeonStatementsToSignals(rows, previous, observedAtIso) {
 
 // src/connectors/neon/resolve.ts
 init_cjs_shims();
-var import_types74 = require("@neat.is/types");
+var import_types75 = 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_types74.infraId)("sql-table", signal.targetName),
+      targetNodeId: (0, import_types75.infraId)("sql-table", signal.targetName),
       serviceName: config.serviceName,
-      edgeType: import_types74.EdgeType.CALLS,
+      edgeType: import_types75.EdgeType.CALLS,
       ensureInfraNode: { kind: "sql-table", name: signal.targetName, provider: "neon" }
     };
   };
@@ -20314,14 +20449,14 @@ function mapLogEntriesToSignals2(entries) {
 
 // src/connectors/cloud-run/resolve.ts
 init_cjs_shims();
-var import_types78 = require("@neat.is/types");
+var import_types79 = 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_types78.NodeType.RouteNode) return;
+    if (node.type !== import_types79.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -20346,13 +20481,13 @@ function createCloudRunResolveTarget(graph, config) {
         normalizePathTemplate(path78)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types78.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types79.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types78.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
+      targetNodeId: (0, import_types79.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
       serviceName: mappedService ?? gcpServiceName,
-      edgeType: import_types78.EdgeType.CALLS,
+      edgeType: import_types79.EdgeType.CALLS,
       ensureInfraNode: {
         kind: CLOUD_RUN_SERVICE_INFRA_KIND,
         name: gcpServiceName,
@@ -20534,14 +20669,14 @@ function mapLogEntriesToSignals3(entries) {
 
 // src/connectors/gcp-lb/resolve.ts
 init_cjs_shims();
-var import_types82 = require("@neat.is/types");
+var import_types83 = require("@neat.is/types");
 var GCP_LB_BACKEND_INFRA_KIND = "gcp-lb-backend";
 function findMatchingRouteNode3(graph, serviceName, method, normalizedPath) {
   let found = null;
   graph.forEachNode((_id, attrs) => {
     if (found) return;
     const node = attrs;
-    if (node.type !== import_types82.NodeType.RouteNode) return;
+    if (node.type !== import_types83.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -20566,13 +20701,13 @@ function createGcpLbResolveTarget(graph, config) {
         normalizePathTemplate(path78)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types82.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types83.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types82.infraId)(GCP_LB_BACKEND_INFRA_KIND, backendServiceName),
+      targetNodeId: (0, import_types83.infraId)(GCP_LB_BACKEND_INFRA_KIND, backendServiceName),
       serviceName: mappedService ?? backendServiceName,
-      edgeType: import_types82.EdgeType.CALLS,
+      edgeType: import_types83.EdgeType.CALLS,
       ensureInfraNode: {
         kind: GCP_LB_BACKEND_INFRA_KIND,
         name: backendServiceName,
@@ -20613,7 +20748,7 @@ function createGcpLbConnector(graph, config = {}) {
 
 // src/connectors/render/index.ts
 init_cjs_shims();
-var import_types85 = require("@neat.is/types");
+var import_types86 = require("@neat.is/types");
 
 // src/connectors/render/types.ts
 init_cjs_shims();
@@ -20691,7 +20826,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types85.NodeType.RouteNode) return;
+    if (node.type !== import_types86.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -20776,7 +20911,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_types85.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types86.EdgeType.CALLS };
     }
     return null;
   };
@@ -20914,21 +21049,21 @@ function mapInsightsToSignals(rows, observedAtIso) {
 
 // src/connectors/planetscale/resolve.ts
 init_cjs_shims();
-var import_types89 = require("@neat.is/types");
+var import_types90 = 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_types89.infraId)("sql-table", signal.targetName);
+    const tableId = (0, import_types90.infraId)("sql-table", signal.targetName);
     if (graph.hasNode(tableId)) {
-      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types89.EdgeType.CALLS };
+      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types90.EdgeType.CALLS };
     }
-    const providerId = (0, import_types89.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
+    const providerId = (0, import_types90.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
     return {
       targetNodeId: providerId,
       serviceName: config.serviceName,
-      edgeType: import_types89.EdgeType.CALLS,
+      edgeType: import_types90.EdgeType.CALLS,
       ensureInfraNode: { kind: PLANETSCALE_DATABASE_KIND, name: databaseName, provider: "planetscale" }
     };
   };
@@ -21193,7 +21328,7 @@ function mapBuildsToSignals(builds, serviceName) {
 
 // src/connectors/eas/resolve.ts
 init_cjs_shims();
-var import_types94 = require("@neat.is/types");
+var import_types95 = 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([
@@ -21209,8 +21344,8 @@ function configBasenamesForPhase(phase) {
 function configNodeService(graph, configNodeId) {
   for (const edgeId of graph.inboundEdges(configNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types94.EdgeType.CONFIGURED_BY) continue;
-    const parsed = (0, import_types94.parseFileId)(edge.source);
+    if (edge.type !== import_types95.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types95.parseFileId)(edge.source);
     if (parsed) return parsed.service;
   }
   return null;
@@ -21221,7 +21356,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== import_types94.NodeType.ConfigNode) return;
+    if (node.type !== import_types95.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;
@@ -21238,13 +21373,13 @@ function createEasResolveTarget(graph) {
     if (basenames.length > 0) {
       const configNodeId = findConfigNode(graph, basenames, serviceName);
       if (configNodeId) {
-        return { targetNodeId: configNodeId, serviceName, edgeType: import_types94.EdgeType.CALLS };
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types95.EdgeType.CALLS };
       }
     }
     return {
       targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
       serviceName,
-      edgeType: import_types94.EdgeType.CALLS
+      edgeType: import_types95.EdgeType.CALLS
     };
   };
 }
@@ -21831,6 +21966,7 @@ async function startConnectorPolling(input) {
       registration.connector,
       {
         projectDir: input.projectDir,
+        project: input.project,
         credentials: registration.credentials,
         ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
       },
@@ -22005,11 +22141,11 @@ function registerRoutes(scope, ctx) {
       const candidates = req2.query.type.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       const parsed = [];
       for (const c of candidates) {
-        const r = import_types97.DivergenceTypeSchema.safeParse(c);
+        const r = import_types98.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types97.DivergenceTypeSchema.options
+            allowed: import_types98.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -22126,6 +22262,7 @@ function registerRoutes(scope, ctx) {
           reg.connector,
           {
             projectDir: proj.scanPath ?? "",
+            project: proj.name,
             credentials: reg.credentials,
             ...incidentsPath ? { errorsPath: incidentsPath } : {}
           },
@@ -22189,6 +22326,39 @@ function registerRoutes(scope, ctx) {
     if (!result) return reply.code(404).send({ error: "no root cause found", id: nodeId });
     return result;
   });
+  scope.get("/graph/incident-card/:nodeId", async (req2, reply) => {
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    const { nodeId } = req2.params;
+    if (!proj.graph.hasNode(nodeId)) {
+      return reply.code(404).send({ error: "node not found", id: nodeId });
+    }
+    const epath = errorsPathFor(proj);
+    const incidents = epath ? await readErrorEvents(epath) : [];
+    let errorEvent;
+    if (req2.query.errorId) {
+      errorEvent = incidents.find((e) => e.id === req2.query.errorId);
+      if (!errorEvent) {
+        return reply.code(404).send({ error: "error event not found", id: req2.query.errorId });
+      }
+    } else {
+      const svc = nodeId.replace(/^service:/, "");
+      errorEvent = [...incidents].filter((e) => e.affectedNode === nodeId || e.service === svc).sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? ""))[0];
+      if (!errorEvent) {
+        return reply.code(404).send({ error: "no incident found for node", id: nodeId });
+      }
+    }
+    const policyPath = ctx.policyFilePathFor(proj);
+    let policies = [];
+    if (policyPath) {
+      try {
+        policies = await loadPolicyFile(policyPath);
+      } catch {
+        policies = [];
+      }
+    }
+    return buildIncidentCard(proj.graph, errorEvent, incidents, policies);
+  });
   scope.get("/graph/blast-radius/:nodeId", async (req2, reply) => {
     const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
@@ -22371,7 +22541,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req2.query.severity) {
-      const sev = import_types97.PolicySeveritySchema.safeParse(req2.query.severity);
+      const sev = import_types98.PolicySeveritySchema.safeParse(req2.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -22410,7 +22580,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req2, reply) => {
     const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
-    const parsed = import_types97.PoliciesCheckBodySchema.safeParse(req2.body ?? {});
+    const parsed = import_types98.PoliciesCheckBodySchema.safeParse(req2.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -22751,7 +22921,7 @@ function unroutedErrorsPath(neatHome4) {
 }
 
 // src/daemon.ts
-var import_types98 = require("@neat.is/types");
+var import_types99 = require("@neat.is/types");
 function daemonJsonPath(scanPath) {
   return import_node_path75.default.join(scanPath, "neat-out", "daemon.json");
 }
@@ -22890,7 +23060,7 @@ function spanBelongsToSingleProject(graph, project, serviceName) {
   if (!serviceName) return true;
   if (serviceNameMatchesProject(serviceName, project)) return true;
   return graph.someNode(
-    (_id, attrs) => attrs.type === import_types98.NodeType.ServiceNode && attrs.name === serviceName
+    (_id, attrs) => attrs.type === import_types99.NodeType.ServiceNode && attrs.name === serviceName
   );
 }
 async function bootstrapProject(entry2, connectors = [], neatHome4) {
@@ -23345,7 +23515,12 @@ async function startDaemon(opts = {}) {
         onErrorSpanSync: async (span) => {
           const slot = await resolveTargetSlot(span.service, span.traceId);
           if (!slot) return;
-          await makeErrorSpanWriter(slot.paths.errorsPath, slot.graph, slot.entry.path)(span);
+          await makeErrorSpanWriter(
+            slot.paths.errorsPath,
+            slot.graph,
+            slot.entry.path,
+            slot.entry.name
+          )(span);
         },
         // Project-scoped route (issue #367) — the URL already named the
         // project. Resolution is a direct slot lookup; service.name resolves
@@ -23368,7 +23543,12 @@ async function startDaemon(opts = {}) {
         onProjectErrorSpanSync: async (project, span) => {
           const slot = await resolveSlotByName(project, span.service, span.traceId);
           if (!slot) return;
-          await makeErrorSpanWriter(slot.paths.errorsPath, slot.graph, slot.entry.path)(span);
+          await makeErrorSpanWriter(
+            slot.paths.errorsPath,
+            slot.graph,
+            slot.entry.path,
+            slot.entry.name
+          )(span);
         },
         // #881 — 404 a project-scoped POST for a project this daemon doesn't
         // host, rather than accepting it and dropping the batch. `slots` covers