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

package/dist/cli.cjs

@@ -6366,11 +6366,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_fs8.promises.mkdir(import_node_path9.default.dirname(ctx.errorsPath), { recursive: true });
   await import_node_fs8.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,
@@ -6384,6 +6398,7 @@ async function appendConnectorIncident(errorsPath, input) {
   };
   await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(errorsPath), { recursive: true });
   await import_node_fs8.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;
@@ -6477,12 +6492,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_fs8.promises.mkdir(import_node_path9.default.dirname(errorsPath), { recursive: true });
     await import_node_fs8.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    emitIncidentEvent(project, ev);
   };
 }
 async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp, statusCode, count, firstTimestamp) {
@@ -16943,7 +16959,7 @@ var import_chokidar = __toESM(require("chokidar"), 1);
 init_cjs_shims();
 var import_fastify2 = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types98 = require("@neat.is/types");
+var import_types99 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -17333,9 +17349,128 @@ function queryLogEntries(opts) {
   return merged;
 }
 
-// src/ask.ts
+// src/goodybag.ts
 init_cjs_shims();
 var import_types60 = 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_types60.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_types60.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_types60.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_types60.IncidentCardSchema.parse(card);
+}
+
+// src/ask.ts
+init_cjs_shims();
+var import_types61 = require("@neat.is/types");
 var DEFAULT_MAX_NODES = 3;
 var MAX_FACTS_PER_SECTION = 6;
 var INTENT_RULES = [
@@ -17563,7 +17698,7 @@ async function resolveEntities(graph, question, searchIndex, maxNodes) {
   };
   graph.forEachNode((id, attrs) => {
     const node = attrs;
-    if (node.type === import_types60.NodeType.FrontierNode) return;
+    if (node.type === import_types61.NodeType.FrontierNode) return;
     const name = nodeName(node);
     const body = idBody(id);
     const labelTokens = /* @__PURE__ */ new Set([...tokens(body), ...tokens(name)]);
@@ -17582,7 +17717,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_types60.NodeType.FrontierNode) continue;
+          if (m.node.type === import_types61.NodeType.FrontierNode) continue;
           const already = best.get(m.node.id);
           if (!already && m.score < EMBED_MIN_SCORE) continue;
           consider({
@@ -17620,7 +17755,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_types60.Provenance.OBSERVED;
+  const lastProv = result.edgeProvenances[result.edgeProvenances.length - 1] ?? import_types61.Provenance.OBSERVED;
   const facts = [
     {
       text: `Root cause: ${result.rootCauseNode} \u2014 ${result.rootCauseReason}`,
@@ -17670,7 +17805,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_types60.Provenance.OBSERVED
+        provenance: import_types61.Provenance.OBSERVED
       });
     } else {
       return null;
@@ -17698,7 +17833,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_types60.Provenance.OBSERVED
+    provenance: import_types61.Provenance.OBSERVED
   }));
   return { heading: `Recent incidents (OBSERVED) \u2014 ${relevant.length} recorded`, facts };
 }
@@ -17758,7 +17893,7 @@ function buildGlobalIncidentsSection(incidents) {
   }
   const byKey = /* @__PURE__ */ new Map();
   for (const ev of incidents) {
-    const key = ev.affectedNode || (0, import_types60.serviceId)(ev.service);
+    const key = ev.affectedNode || (0, import_types61.serviceId)(ev.service);
     const cur = byKey.get(key);
     if (!cur) {
       byKey.set(key, { key, count: 1, latest: ev.timestamp, sampleMsg: ev.errorMessage });
@@ -17773,7 +17908,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_types60.Provenance.OBSERVED
+    provenance: import_types61.Provenance.OBSERVED
   }));
   return {
     heading: `Incidents across the system \u2014 ${incidents.length} recorded`,
@@ -17786,7 +17921,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_types60.NodeType.ServiceNode) services.push(node.id);
+    if (node.type === import_types61.NodeType.ServiceNode) services.push(node.id);
   });
   const edgeByProv = /* @__PURE__ */ new Map();
   graph.forEachEdge((_id, attrs) => {
@@ -17798,10 +17933,10 @@ function buildOverviewSections(graph, incidents) {
   const shapeFacts = [
     { text: `${graph.order} nodes, ${graph.size} edges` },
     {
-      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`
+      text: `${count(import_types61.NodeType.ServiceNode)} services, ${count(import_types61.NodeType.FileNode)} files, ${count(import_types61.NodeType.SymbolNode)} symbols, ${count(import_types61.NodeType.DatabaseNode)} databases`
     }
   ];
-  for (const p of [import_types60.Provenance.EXTRACTED, import_types60.Provenance.OBSERVED, import_types60.Provenance.INFERRED, import_types60.Provenance.STALE]) {
+  for (const p of [import_types61.Provenance.EXTRACTED, import_types61.Provenance.OBSERVED, import_types61.Provenance.INFERRED, import_types61.Provenance.STALE]) {
     const n = edgeByProv.get(p) ?? 0;
     if (n > 0) shapeFacts.push({ text: `${n} ${p} edge${n === 1 ? "" : "s"}`, provenance: p });
   }
@@ -17818,7 +17953,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_types60.serviceId)(ev.service);
+      const key = ev.affectedNode || (0, import_types61.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);
@@ -17826,7 +17961,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_types60.Provenance.OBSERVED
+        provenance: import_types61.Provenance.OBSERVED
       }))
     });
   }
@@ -17962,7 +18097,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_types60.AskResultSchema.parse({
+  return import_types61.AskResultSchema.parse({
     question,
     intent,
     matched,
@@ -18109,7 +18244,7 @@ init_cjs_shims();
 var import_node_fs39 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path74 = __toESM(require("path"), 1);
-var import_types61 = require("@neat.is/types");
+var import_types62 = require("@neat.is/types");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
@@ -18363,10 +18498,10 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types61.RegistryFileSchema.parse(parsed);
+  return import_types62.RegistryFileSchema.parse(parsed);
 }
 async function writeRegistry(reg) {
-  const validated = import_types61.RegistryFileSchema.parse(reg);
+  const validated = import_types62.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
 var ProjectNameCollisionError = class extends Error {
@@ -18879,15 +19014,15 @@ function getConnectorStatus(id, now = Date.now(), thresholdMs = CONNECTOR_STALE_
 
 // src/connectors/index.ts
 init_cjs_shims();
-var import_types62 = require("@neat.is/types");
+var import_types63 = 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_types62.Provenance.EXTRACTED) continue;
-    const parsed = (0, import_types62.parseFileId)(edge.source);
+    if (edge.provenance !== import_types63.Provenance.EXTRACTED) continue;
+    const parsed = (0, import_types63.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;
@@ -18898,7 +19033,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_types62.NodeType.RouteNode || !attrs.path) return void 0;
+  if (attrs.type !== import_types63.NodeType.RouteNode || !attrs.path) return void 0;
   const site = { relPath: attrs.path };
   if (attrs.line !== void 0) site.line = attrs.line;
   return site;
@@ -18928,7 +19063,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) {
@@ -19510,23 +19645,23 @@ async function fetchPgStatStatements(connectionString, limit = DEFAULT_STATEMENT
 
 // src/connectors/supabase/resolve.ts
 init_cjs_shims();
-var import_types64 = require("@neat.is/types");
+var import_types65 = 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_types64.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
+    const subResourceId = (0, import_types65.infraId)(signal.targetKind, `${config.nodeRef}/${signal.targetName}`);
     if (graph.hasNode(subResourceId)) {
-      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types64.EdgeType.CALLS };
+      return { targetNodeId: subResourceId, serviceName: config.serviceName, edgeType: import_types65.EdgeType.CALLS };
     }
-    const bareResourceId = (0, import_types64.infraId)(signal.targetKind, signal.targetName);
+    const bareResourceId = (0, import_types65.infraId)(signal.targetKind, signal.targetName);
     if (graph.hasNode(bareResourceId)) {
-      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types64.EdgeType.CALLS };
+      return { targetNodeId: bareResourceId, serviceName: config.serviceName, edgeType: import_types65.EdgeType.CALLS };
     }
-    const projectLevelId = (0, import_types64.infraId)("supabase", config.nodeRef);
+    const projectLevelId = (0, import_types65.infraId)("supabase", config.nodeRef);
     if (graph.hasNode(projectLevelId)) {
-      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types64.EdgeType.CALLS };
+      return { targetNodeId: projectLevelId, serviceName: config.serviceName, edgeType: import_types65.EdgeType.CALLS };
     }
     return null;
   };
@@ -19619,7 +19754,7 @@ function createSupabaseConnector(graph, config, deps = {}) {
 
 // src/connectors/railway/index.ts
 init_cjs_shims();
-var import_types68 = require("@neat.is/types");
+var import_types69 = require("@neat.is/types");
 
 // src/connectors/railway/client.ts
 init_cjs_shims();
@@ -19770,7 +19905,7 @@ function buildRailwayRouteIndex(graph, serviceName) {
   const out = [];
   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;
     out.push({
@@ -19874,12 +20009,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_types68.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName, edgeType: import_types69.EdgeType.CALLS };
     }
     if (signal.targetKind === PEER_SERVICE_TARGET_KIND) {
       const peerName = config.serviceNameById[signal.targetName];
       if (!peerName) return null;
-      return { targetNodeId: (0, import_types68.serviceId)(peerName), serviceName, edgeType: import_types68.EdgeType.CONNECTS_TO };
+      return { targetNodeId: (0, import_types69.serviceId)(peerName), serviceName, edgeType: import_types69.EdgeType.CONNECTS_TO };
     }
     return null;
   };
@@ -20067,7 +20202,7 @@ function mapLogEntriesToSignals(entries) {
 
 // src/connectors/firebase/resolve.ts
 init_cjs_shims();
-var import_types69 = require("@neat.is/types");
+var import_types70 = require("@neat.is/types");
 function neatServiceNameFor(resourceType, resourceName, serviceMap) {
   switch (resourceType) {
     case "cloud_function":
@@ -20082,7 +20217,7 @@ function routeEntriesFor(graph, serviceName) {
   const entries = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types69.NodeType.RouteNode) return;
+    if (node.type !== import_types70.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     entries.push({
@@ -20114,7 +20249,7 @@ function createFirebaseResolveTarget(graph, serviceMap) {
     return {
       targetNodeId: match.routeNodeId,
       serviceName,
-      edgeType: import_types69.EdgeType.CALLS
+      edgeType: import_types70.EdgeType.CALLS
     };
   };
 }
@@ -20141,7 +20276,7 @@ init_cjs_shims();
 
 // src/connectors/cloudflare/connector.ts
 init_cjs_shims();
-var import_types71 = require("@neat.is/types");
+var import_types72 = require("@neat.is/types");
 
 // src/connectors/cloudflare/client.ts
 init_cjs_shims();
@@ -20305,7 +20440,7 @@ function findTaggedWorkerFileNode(graph, workerName) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type === import_types71.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
+    if (a.type === import_types72.NodeType.FileNode && a.platform === "cloudflare" && a.platformName === workerName) {
       found = id;
     }
   });
@@ -20317,7 +20452,7 @@ function findMatchingRouteNode(graph, serviceName, method, path94) {
   graph.forEachNode((id, attrs) => {
     if (found) return;
     const a = attrs;
-    if (a.type !== import_types71.NodeType.RouteNode || a.service !== serviceName) return;
+    if (a.type !== import_types72.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;
@@ -20336,11 +20471,11 @@ function createCloudflareResolveTarget(config, graph) {
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
-      const wholeFileId = (0, import_types71.fileId)(mapping.service, mapping.entryFile);
+      const wholeFileId = (0, import_types72.fileId)(mapping.service, mapping.entryFile);
       return {
         targetNodeId: resolveRouteGrain(mapping.service, wholeFileId),
         serviceName: mapping.service,
-        edgeType: import_types71.EdgeType.CALLS
+        edgeType: import_types72.EdgeType.CALLS
       };
     }
     const taggedFileId = findTaggedWorkerFileNode(graph, scriptName);
@@ -20349,13 +20484,13 @@ function createCloudflareResolveTarget(config, graph) {
       return {
         targetNodeId: resolveRouteGrain(fileNode.service, taggedFileId),
         serviceName: fileNode.service,
-        edgeType: import_types71.EdgeType.CALLS
+        edgeType: import_types72.EdgeType.CALLS
       };
     }
     return {
-      targetNodeId: (0, import_types71.infraId)("cloudflare-worker", scriptName),
+      targetNodeId: (0, import_types72.infraId)("cloudflare-worker", scriptName),
       serviceName: scriptName,
-      edgeType: import_types71.EdgeType.CALLS,
+      edgeType: import_types72.EdgeType.CALLS,
       ensureInfraNode: { kind: "cloudflare-worker", name: scriptName, provider: "cloudflare" }
     };
   };
@@ -20551,14 +20686,14 @@ function diffNeonStatementsToSignals(rows, previous, observedAtIso) {
 
 // src/connectors/neon/resolve.ts
 init_cjs_shims();
-var import_types75 = require("@neat.is/types");
+var import_types76 = 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_types75.infraId)("sql-table", signal.targetName),
+      targetNodeId: (0, import_types76.infraId)("sql-table", signal.targetName),
       serviceName: config.serviceName,
-      edgeType: import_types75.EdgeType.CALLS,
+      edgeType: import_types76.EdgeType.CALLS,
       ensureInfraNode: { kind: "sql-table", name: signal.targetName, provider: "neon" }
     };
   };
@@ -20739,14 +20874,14 @@ function mapLogEntriesToSignals2(entries) {
 
 // src/connectors/cloud-run/resolve.ts
 init_cjs_shims();
-var import_types79 = require("@neat.is/types");
+var import_types80 = 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_types79.NodeType.RouteNode) return;
+    if (node.type !== import_types80.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -20771,13 +20906,13 @@ function createCloudRunResolveTarget(graph, config) {
         normalizePathTemplate(path94)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types79.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types80.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types79.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
+      targetNodeId: (0, import_types80.infraId)(CLOUD_RUN_SERVICE_INFRA_KIND, gcpServiceName),
       serviceName: mappedService ?? gcpServiceName,
-      edgeType: import_types79.EdgeType.CALLS,
+      edgeType: import_types80.EdgeType.CALLS,
       ensureInfraNode: {
         kind: CLOUD_RUN_SERVICE_INFRA_KIND,
         name: gcpServiceName,
@@ -20959,14 +21094,14 @@ function mapLogEntriesToSignals3(entries) {
 
 // src/connectors/gcp-lb/resolve.ts
 init_cjs_shims();
-var import_types83 = require("@neat.is/types");
+var import_types84 = 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_types83.NodeType.RouteNode) return;
+    if (node.type !== import_types84.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName || !route.pathTemplate) return;
     if (normalizePathTemplate(route.pathTemplate) !== normalizedPath) return;
@@ -20991,13 +21126,13 @@ function createGcpLbResolveTarget(graph, config) {
         normalizePathTemplate(path94)
       );
       if (routeNodeId) {
-        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types83.EdgeType.CALLS };
+        return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types84.EdgeType.CALLS };
       }
     }
     return {
-      targetNodeId: (0, import_types83.infraId)(GCP_LB_BACKEND_INFRA_KIND, backendServiceName),
+      targetNodeId: (0, import_types84.infraId)(GCP_LB_BACKEND_INFRA_KIND, backendServiceName),
       serviceName: mappedService ?? backendServiceName,
-      edgeType: import_types83.EdgeType.CALLS,
+      edgeType: import_types84.EdgeType.CALLS,
       ensureInfraNode: {
         kind: GCP_LB_BACKEND_INFRA_KIND,
         name: backendServiceName,
@@ -21038,7 +21173,7 @@ function createGcpLbConnector(graph, config = {}) {
 
 // src/connectors/render/index.ts
 init_cjs_shims();
-var import_types86 = require("@neat.is/types");
+var import_types87 = require("@neat.is/types");
 
 // src/connectors/render/types.ts
 init_cjs_shims();
@@ -21116,7 +21251,7 @@ function buildRenderRouteIndex(graph, serviceName) {
   const out = [];
   graph.forEachNode((_id, attrs) => {
     const node = attrs;
-    if (node.type !== import_types86.NodeType.RouteNode) return;
+    if (node.type !== import_types87.NodeType.RouteNode) return;
     const route = attrs;
     if (route.service !== serviceName) return;
     out.push({
@@ -21201,7 +21336,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_types86.EdgeType.CALLS };
+      return { targetNodeId: signal.targetName, serviceName: config.serviceName, edgeType: import_types87.EdgeType.CALLS };
     }
     return null;
   };
@@ -21339,21 +21474,21 @@ function mapInsightsToSignals(rows, observedAtIso) {
 
 // src/connectors/planetscale/resolve.ts
 init_cjs_shims();
-var import_types90 = require("@neat.is/types");
+var import_types91 = 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_types90.infraId)("sql-table", signal.targetName);
+    const tableId = (0, import_types91.infraId)("sql-table", signal.targetName);
     if (graph.hasNode(tableId)) {
-      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types90.EdgeType.CALLS };
+      return { targetNodeId: tableId, serviceName: config.serviceName, edgeType: import_types91.EdgeType.CALLS };
     }
-    const providerId = (0, import_types90.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
+    const providerId = (0, import_types91.infraId)(PLANETSCALE_DATABASE_KIND, databaseName);
     return {
       targetNodeId: providerId,
       serviceName: config.serviceName,
-      edgeType: import_types90.EdgeType.CALLS,
+      edgeType: import_types91.EdgeType.CALLS,
       ensureInfraNode: { kind: PLANETSCALE_DATABASE_KIND, name: databaseName, provider: "planetscale" }
     };
   };
@@ -21618,7 +21753,7 @@ function mapBuildsToSignals(builds, serviceName) {
 
 // src/connectors/eas/resolve.ts
 init_cjs_shims();
-var import_types95 = require("@neat.is/types");
+var import_types96 = 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([
@@ -21634,8 +21769,8 @@ function configBasenamesForPhase(phase) {
 function configNodeService(graph, configNodeId) {
   for (const edgeId of graph.inboundEdges(configNodeId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types95.EdgeType.CONFIGURED_BY) continue;
-    const parsed = (0, import_types95.parseFileId)(edge.source);
+    if (edge.type !== import_types96.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types96.parseFileId)(edge.source);
     if (parsed) return parsed.service;
   }
   return null;
@@ -21646,7 +21781,7 @@ function findConfigNode(graph, basenames, serviceName) {
   graph.forEachNode((id, attrs) => {
     if (scoped) return;
     const node = attrs;
-    if (node.type !== import_types95.NodeType.ConfigNode) return;
+    if (node.type !== import_types96.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;
@@ -21663,13 +21798,13 @@ function createEasResolveTarget(graph) {
     if (basenames.length > 0) {
       const configNodeId = findConfigNode(graph, basenames, serviceName);
       if (configNodeId) {
-        return { targetNodeId: configNodeId, serviceName, edgeType: import_types95.EdgeType.CALLS };
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types96.EdgeType.CALLS };
       }
     }
     return {
       targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
       serviceName,
-      edgeType: import_types95.EdgeType.CALLS
+      edgeType: import_types96.EdgeType.CALLS
     };
   };
 }
@@ -22287,6 +22422,7 @@ async function startConnectorPolling(input) {
       registration.connector,
       {
         projectDir: input.projectDir,
+        project: input.project,
         credentials: registration.credentials,
         ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
       },
@@ -22509,11 +22645,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_types98.DivergenceTypeSchema.safeParse(c);
+        const r = import_types99.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types98.DivergenceTypeSchema.options
+            allowed: import_types99.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -22630,6 +22766,7 @@ function registerRoutes(scope, ctx) {
           reg.connector,
           {
             projectDir: proj.scanPath ?? "",
+            project: proj.name,
             credentials: reg.credentials,
             ...incidentsPath ? { errorsPath: incidentsPath } : {}
           },
@@ -22693,6 +22830,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 (req, reply) => {
+    const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
+    if (!proj) return;
+    const { nodeId } = req.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 (req.query.errorId) {
+      errorEvent = incidents.find((e) => e.id === req.query.errorId);
+      if (!errorEvent) {
+        return reply.code(404).send({ error: "error event not found", id: req.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 (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
@@ -22875,7 +23045,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types98.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types99.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -22914,7 +23084,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_types98.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types99.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -23247,7 +23417,7 @@ var import_node_fs41 = require("fs");
 var import_node_path76 = __toESM(require("path"), 1);
 
 // src/daemon.ts
-var import_types99 = require("@neat.is/types");
+var import_types100 = require("@neat.is/types");
 function daemonJsonPath(scanPath) {
   return import_node_path77.default.join(scanPath, "neat-out", "daemon.json");
 }
@@ -23957,7 +24127,7 @@ async function startWatch(graph, opts) {
     writeErrorEventInline: false,
     onPolicyTrigger
   });
-  const onErrorSpanSync = makeErrorSpanWriter(opts.errorsPath, graph, opts.scanPath);
+  const onErrorSpanSync = makeErrorSpanWriter(opts.errorsPath, graph, opts.scanPath, projectName);
   const otelHttp = await buildOtelReceiver({ onSpan, onErrorSpanSync });
   const otelAddress = await listenSteppingOtlp(otelHttp, otelPort, host);
   const boundOtelPort = portFromListenAddress(otelAddress, otelPort);
@@ -28264,7 +28434,7 @@ var import_node_path87 = __toESM(require("path"), 1);
 
 // src/cli-client.ts
 init_cjs_shims();
-var import_types100 = require("@neat.is/types");
+var import_types101 = require("@neat.is/types");
 var HttpError = class extends Error {
   constructor(status2, message, responseBody = "") {
     super(message);
@@ -28406,7 +28576,7 @@ async function runBlastRadius(client, input) {
   }
 }
 function formatBlastEntry(n) {
-  const tag = n.edgeProvenance === import_types100.Provenance.STALE ? " [STALE \u2014 last seen too long ago]" : "";
+  const tag = n.edgeProvenance === import_types101.Provenance.STALE ? " [STALE \u2014 last seen too long ago]" : "";
   return `  \u2022 ${n.nodeId} (distance ${n.distance}, ${n.edgeProvenance})${tag}`;
 }
 async function runDependencies(client, input) {
@@ -28463,7 +28633,7 @@ async function runObservedDependencies(client, input) {
       if (result.observed) {
         return {
           summary: `${input.nodeId} makes no outbound runtime calls, but OTel has observed it receiving traffic on ${result.inboundObservedCount} inbound call path${result.inboundObservedCount === 1 ? "" : "s"} \u2014 it's a pure receiver.`,
-          provenance: import_types100.Provenance.OBSERVED
+          provenance: import_types101.Provenance.OBSERVED
         };
       }
       const note = result.hasExtractedOutbound ? " Static (EXTRACTED) dependencies exist but no runtime traffic has been seen \u2014 is OTel running?" : "";
@@ -28473,7 +28643,7 @@ async function runObservedDependencies(client, input) {
     return {
       summary: `${input.nodeId} has ${result.dependencies.length} runtime dependenc${result.dependencies.length === 1 ? "y" : "ies"} confirmed by OTel.`,
       block: blockLines.join("\n"),
-      provenance: import_types100.Provenance.OBSERVED
+      provenance: import_types101.Provenance.OBSERVED
     };
   } catch (err) {
     if (err instanceof HttpError && err.status === 404) {
@@ -28527,7 +28697,7 @@ async function runIncidents(client, input) {
     return {
       summary: `${target} has ${body.total} recorded incident${body.total === 1 ? "" : "s"}; showing the ${ordered.length} most recent.`,
       block: blockLines.join("\n"),
-      provenance: import_types100.Provenance.OBSERVED
+      provenance: import_types101.Provenance.OBSERVED
     };
   } catch (err) {
     if (err instanceof HttpError && err.status === 404) {
@@ -28636,7 +28806,7 @@ async function runStaleEdges(client, input) {
   return {
     summary: `${events.length} stale-edge transition${events.length === 1 ? "" : "s"} recorded${input.edgeType ? ` for ${input.edgeType}` : ""}.`,
     block: blockLines.join("\n"),
-    provenance: import_types100.Provenance.STALE
+    provenance: import_types101.Provenance.STALE
   };
 }
 async function runPolicies(client, input) {
@@ -29927,12 +30097,12 @@ async function runEditorCommand(clientId, args, projectDir = process.cwd()) {
 
 // src/monitor.ts
 init_cjs_shims();
-var import_types101 = require("@neat.is/types");
+var import_types102 = require("@neat.is/types");
 var OBSERVED_DEP_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types101.EdgeType.CALLS,
-  import_types101.EdgeType.CONNECTS_TO,
-  import_types101.EdgeType.PUBLISHES_TO,
-  import_types101.EdgeType.CONSUMES_FROM
+  import_types102.EdgeType.CALLS,
+  import_types102.EdgeType.CONNECTS_TO,
+  import_types102.EdgeType.PUBLISHES_TO,
+  import_types102.EdgeType.CONSUMES_FROM
 ]);
 function divergenceKey(d) {
   const column = "column" in d && d.column ? d.column : "";
@@ -29993,7 +30163,7 @@ function formatDivergenceLine2(d) {
   }
 }
 function formatStaleLine(edgeId) {
-  const parsed = (0, import_types101.parseEdgeId)(edgeId);
+  const parsed = (0, import_types102.parseEdgeId)(edgeId);
   if (parsed) {
     return `\u22EF stale  ${parsed.source} \u2192 ${parsed.target}  (observed edge went quiet)`;
   }
@@ -30006,7 +30176,7 @@ function divergenceJson(d) {
   return JSON.stringify({ kind: "divergence", ...d });
 }
 function staleJson(edgeId) {
-  const parsed = (0, import_types101.parseEdgeId)(edgeId);
+  const parsed = (0, import_types102.parseEdgeId)(edgeId);
   return JSON.stringify({
     kind: "stale",
     edgeId,
@@ -30041,6 +30211,19 @@ function formatPolicyLine(v) {
 function policyJson(v) {
   return JSON.stringify({ kind: "policy", ...v });
 }
+function formatIncidentLine(card) {
+  let tag = "";
+  if (card.rootCause) {
+    const rc = card.rootCause;
+    const provs = rc.chain.map((h) => h.provenance).join("\xB7");
+    const cls = rc.classification ? `${rc.classification} ` : "";
+    tag = `  \xB7 ${cls}${rc.confidence.toFixed(2)}${provs ? ` [${provs}]` : ""}`;
+  }
+  return `\u2716 incident [${card.incidentKind}]  ${card.headline}${tag}`;
+}
+function incidentJson(card) {
+  return JSON.stringify(card);
+}
 var MonitorEmitter = class {
   constructor(opts) {
     this.opts = opts;
@@ -30076,7 +30259,7 @@ var MonitorEmitter = class {
   // ignores non-OBSERVED edges and non-dependency edge types (structural
   // ownership), so only real runtime dependencies reach stdout.
   emitObservedEdge(edge) {
-    if (edge.provenance !== import_types101.Provenance.OBSERVED) return false;
+    if (edge.provenance !== import_types102.Provenance.OBSERVED) return false;
     if (!OBSERVED_DEP_EDGE_TYPES.has(edge.type)) return false;
     const key = `edge|${edge.id}`;
     if (this.seen.has(key)) return false;
@@ -30098,6 +30281,17 @@ var MonitorEmitter = class {
     }
     return emitted;
   }
+  // Emit one incident card once, keyed on the incident id. Unlike the other
+  // facts this is event-driven, not a re-read of derivable state, so there is no
+  // baseline dump on connect — only incidents that arrive live after the monitor
+  // is watching reach stdout.
+  emitIncident(card) {
+    const key = `incident|${card.id}`;
+    if (this.seen.has(key)) return false;
+    this.seen.add(key);
+    this.out(this.opts.json ? incidentJson(card) : formatIncidentLine(card));
+    return true;
+  }
 };
 function parseFrame(raw) {
   let event = "message";
@@ -30219,6 +30413,18 @@ async function runMonitor(opts) {
     const result = await client.get(policiesPath);
     emitter.emitPolicies(result);
   }, debounceMs);
+  const readIncidentCard = async (incidentId, affectedNode) => {
+    try {
+      const card = await client.get(
+        projectPath2(
+          opts.project,
+          `/graph/incident-card/${encodeURIComponent(affectedNode)}?errorId=${encodeURIComponent(incidentId)}`
+        )
+      );
+      emitter.emitIncident(card);
+    } catch {
+    }
+  };
   const onFrame = (frame) => {
     switch (frame.event) {
       case "extraction-complete":
@@ -30234,7 +30440,7 @@ async function runMonitor(opts) {
       case "edge-added": {
         const payload = safeParse(frame.data);
         const edge = payload?.edge;
-        if (edge && edge.provenance === import_types101.Provenance.OBSERVED) {
+        if (edge && edge.provenance === import_types102.Provenance.OBSERVED) {
           emitter.emitObservedEdge(edge);
           divergences.schedule();
         }
@@ -30243,6 +30449,13 @@ async function runMonitor(opts) {
       case "policy-violation":
         policies.schedule();
         break;
+      case "incident": {
+        const payload = safeParse(frame.data);
+        const incidentId = payload && typeof payload.incidentId === "string" ? payload.incidentId : void 0;
+        const affectedNode = payload && typeof payload.affectedNode === "string" ? payload.affectedNode : void 0;
+        if (incidentId && affectedNode) void readIncidentCard(incidentId, affectedNode);
+        break;
+      }
       default:
         break;
     }
@@ -30477,7 +30690,7 @@ async function runSync(opts) {
 }
 
 // src/cli.ts
-var import_types102 = require("@neat.is/types");
+var import_types103 = require("@neat.is/types");
 function isNpxInvocation() {
   if (process.env.npm_command === "exec") return true;
   const execpath = process.env.npm_execpath ?? "";
@@ -31561,10 +31774,10 @@ async function runQueryVerb(cmd, parsed) {
         const parts = parsed.type.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
         const out = [];
         for (const p of parts) {
-          const r = import_types102.DivergenceTypeSchema.safeParse(p);
+          const r = import_types103.DivergenceTypeSchema.safeParse(p);
           if (!r.success) {
             console.error(
-              `neat divergences: unknown --type "${p}". allowed: ${import_types102.DivergenceTypeSchema.options.join(", ")}`
+              `neat divergences: unknown --type "${p}". allowed: ${import_types103.DivergenceTypeSchema.options.join(", ")}`
             );
             return 2;
           }