@neat.is/core 0.8.1-dev.20260816 → 0.8.1

package/dist/cli.cjs

@@ -1472,7 +1472,11 @@ function legacyRootCause(graph, errorNodeId, errorEvent, incidents) {
 }
 var INCIDENT_ROOT_CAUSE_CONFIDENCE = 0.6;
 function incidentMatchesNode(ev, nodeId) {
-  return ev.affectedNode === nodeId || ev.service === nodeId.replace(/^service:/, "");
+  if (ev.affectedNode === nodeId) return true;
+  if (ev.service === nodeId.replace(/^service:/, "")) return true;
+  const sym = (0, import_types.parseSymbolId)(ev.affectedNode);
+  if (sym && (0, import_types.fileId)(sym.service, sym.relPath) === nodeId) return true;
+  return false;
 }
 function localizeFromIncidents(nodeId, incidents, errorEvent) {
   const pool = incidents && incidents.length > 0 ? incidents : errorEvent ? [errorEvent] : [];
@@ -1490,8 +1494,8 @@ function localizeFromIncidents(nodeId, incidents, errorEvent) {
   const reasonParts = [`${latest.service}: ${latest.errorMessage}`];
   if (location) reasonParts.push(`surfaced at ${location}`);
   const rootCauseReason = `${reasonParts.join(" \u2014 ")}${tail}`;
-  const localizesToFile = latest.affectedNode !== nodeId && latest.affectedNode.startsWith("file:");
-  const fileNode = localizesToFile ? latest.affectedNode : void 0;
+  const localizesFiner = latest.affectedNode !== nodeId && (latest.affectedNode.startsWith("file:") || latest.affectedNode.startsWith("symbol:"));
+  const fileNode = localizesFiner ? latest.affectedNode : void 0;
   const fixRecommendation = location ? `Inspect ${location}${route ? ` handling ${route}` : ""}` : route ? `Inspect ${latest.service}'s handler for ${route}` : void 0;
   return {
     rootCauseNode: fileNode ?? nodeId,
@@ -1976,6 +1980,22 @@ function findLoadOrigin(graph, alertNodeId, incidents, now) {
   }
   return best ? { node: best.node, ctx: best.ctx } : null;
 }
+var LOAD_ORIGIN_CONFIDENCE_CEILING = 0.9;
+function loadOriginConfidence(originCtx, seedCtx) {
+  const cleanSplit = seedCtx.errorsFromCallers > 0 && seedCtx.errorsEmittedHere === 0;
+  const partialSplit = seedCtx.errorsFromCallers > seedCtx.errorsEmittedHere;
+  let evidence = 0;
+  evidence += cleanSplit ? 0.45 : partialSplit ? 0.2 : 0;
+  evidence += seedCtx.stale ? 0.2 : 0;
+  evidence += isSaturated(seedCtx) ? 0.15 : 0;
+  evidence += (volumeWeight(originCtx.outboundVolume) - 0.5) * 0.4;
+  const anchor = 0.45;
+  const confidence = anchor + Math.min(1, evidence) * (LOAD_ORIGIN_CONFIDENCE_CEILING - anchor);
+  return Math.max(0, Math.min(LOAD_ORIGIN_CONFIDENCE_CEILING, confidence));
+}
+function displayNameOf(nodeId) {
+  return nodeId.replace(/^[a-z]+:/, "");
+}
 function getRootCause(graph, errorNodeId, errorEvent, incidents, opts) {
   const legacy = legacyRootCause(graph, errorNodeId, errorEvent, incidents);
   if (!legacy) return null;
@@ -1990,20 +2010,20 @@ function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
   const candidates = [];
   if (seedCtx && isVictimSeed(seedCtx)) {
     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` : "";
     if (origin) {
-      const path84 = findPath(graph, errorNodeId, origin.node, "up", ROOT_CAUSE_MAX_DEPTH);
-      const originConfidence = confidenceFromMix(path84?.edges ?? [], now);
+      const originName = displayNameOf(origin.node);
+      const seedName = displayNameOf(seedNode);
       candidates.push({
         node: origin.node,
         classification: "primary-failure",
-        reason: `Highest-volume upstream source (${origin.ctx.outboundVolume} observed outbound calls) driving a saturated/stale subgraph; the alerting path decays downstream into a starved victim rather than a fault at the callee.`,
+        reason: `${originName} is the root cause: it overloads the failing subgraph, and the alerting node ${seedName} is a downstream symptom, not the fault \u2014 errors reach ${seedName} from its callers (${seedCtx.errorsFromCallers}), none originate there${staleNote}${satNote}. ${originName} is the upstream source driving that load (${origin.ctx.outboundVolume} observed outbound calls).`,
         context: origin.ctx,
-        confidence: Math.max(0.3, Math.min(0.8, originConfidence || 0.5)),
+        confidence: loadOriginConfidence(origin.ctx, seedCtx),
         provenance: import_types.Provenance.OBSERVED
       });
     }
-    const staleNote = seedCtx.stale ? "; the node has gone STALE" : "";
-    const satNote = isSaturated(seedCtx) ? `; inbound p95 ${Math.round(seedCtx.latencyP95Ms)}ms is saturated` : "";
     candidates.push({
       node: seedNode,
       classification: "symptom-only",
@@ -2035,16 +2055,27 @@ function enrichWithNavigation(graph, errorNodeId, legacy, incidents, now) {
       edgeProvenances = [top.provenance ?? import_types.Provenance.OBSERVED];
     }
   }
+  const fixRecommendation = fixRecommendationForTop(top, seedNode, legacy);
   return import_types.RootCauseResultSchema.parse({
     rootCauseNode: top.node,
     rootCauseReason: top.reason,
     traversalPath,
     edgeProvenances,
     confidence: top.confidence,
-    ...legacy.fixRecommendation ? { fixRecommendation: legacy.fixRecommendation } : {},
+    ...fixRecommendation ? { fixRecommendation } : {},
     candidates
   });
 }
+function fixRecommendationForTop(top, seedNode, legacy) {
+  if (top.classification === "primary-failure" && top.node === seedNode) {
+    return legacy.fixRecommendation;
+  }
+  const name = top.node.replace(/^service:/, "");
+  if (top.classification === "primary-failure") {
+    return `Reduce or throttle the load from ${name} (or scale the saturated downstream capacity it drives) \u2014 the failure originates at this overloading source, not the starved callee.`;
+  }
+  return `${name} is a saturated/starved downstream victim; investigate its inbound load and upstream callers, not its own handler.`;
+}
 
 // src/policy.ts
 var DEFAULT_ACTION_BY_SEVERITY = {
@@ -5391,7 +5422,7 @@ function ensureObservedSymbolNode(graph, fileNodeId, service, relPath, fn, line)
   }
   return sid;
 }
-function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
+function landObservedSymbol(graph, fileNodeId, service, relPath, callSite, mint = true) {
   const line = callSite.line;
   if (line === void 0) return fileNodeId;
   let sawSymbol = false;
@@ -5406,7 +5437,7 @@ function landObservedSymbol(graph, fileNodeId, service, relPath, callSite) {
     }
   });
   if (candidates.length > 0) return pickContainingSymbol(candidates, callSite.fn);
-  if (sawSymbol && callSite.fn) {
+  if (mint && sawSymbol && callSite.fn) {
     return ensureObservedSymbolNode(graph, fileNodeId, service, relPath, callSite.fn, line);
   }
   return fileNodeId;
@@ -5812,6 +5843,20 @@ function incidentAffectedNode(span, graph, scanPath) {
   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_types8.fileId)(canonicalService, relPath);
+      if (graph.hasNode(fusedFileId)) {
+        return landObservedSymbol(
+          graph,
+          fusedFileId,
+          canonicalService,
+          relPath,
+          { ...callSite, relPath },
+          false
+        );
+      }
+    }
     return (0, import_types8.fileId)(span.service, relPath);
   }
   return sid;
@@ -6175,7 +6220,11 @@ async function handleSpan(ctx, span) {
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
-        affectedNode
+        // 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)
       };
       await appendErrorEvent(ctx, ev);
     }