@neat.is/core 0.10.6-dev.20261007 → 0.10.6-dev.20261009

package/dist/server.cjs

@@ -5678,7 +5678,29 @@ function ensureFrontierNode(graph, host, ts) {
   graph.addNode(id, node);
   return id;
 }
-function upsertObservedEdge(graph, type, source, target, ts, isError = false, evidence, durationMs) {
+var EDGE_ERROR_MESSAGE_MAX = 512;
+function buildEdgeErrorExemplar(detail, ts) {
+  return {
+    ...detail.exceptionType !== void 0 ? { exceptionType: detail.exceptionType } : {},
+    ...detail.message !== void 0 ? { message: detail.message.slice(0, EDGE_ERROR_MESSAGE_MAX) } : {},
+    ...detail.httpStatusCode !== void 0 ? { httpStatusCode: detail.httpStatusCode } : {},
+    at: ts
+  };
+}
+function edgeErrorDetailFromSpan(span) {
+  const exceptionType = span.exception?.type;
+  const message = span.exception?.message;
+  const httpStatusCode = httpResponseStatus(span);
+  if (exceptionType === void 0 && message === void 0 && httpStatusCode === void 0) {
+    return void 0;
+  }
+  return {
+    ...exceptionType !== void 0 ? { exceptionType } : {},
+    ...message !== void 0 ? { message } : {},
+    ...httpStatusCode !== void 0 ? { httpStatusCode } : {}
+  };
+}
+function upsertObservedEdge(graph, type, source, target, ts, isError = false, evidence, durationMs, errorDetail) {
   if (!graph.hasNode(source) || !graph.hasNode(target)) return null;
   const grain = source.startsWith("file:") || source.startsWith("symbol:") ? "file" : "service";
   const id = makeObservedEdgeId(type, source, target);
@@ -5688,13 +5710,15 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     const newErrorCount = (existing.signal?.errorCount ?? 0) + (isError ? 1 : 0);
     const latencyHist2 = durationMs !== void 0 ? recordLatency({ ...existing.signal?.latencyHist ?? {} }, durationMs) : existing.signal?.latencyHist;
     const latencyMs2 = latencyPercentiles(latencyHist2) ?? existing.signal?.latencyMs;
+    const lastError2 = isError && errorDetail ? buildEdgeErrorExemplar(errorDetail, ts) : existing.signal?.lastError;
     const newSignal = {
       spanCount: newSpanCount,
       errorCount: newErrorCount,
       lastObservedAgeMs: 0,
       ...latencyHist2 ? { latencyHist: latencyHist2 } : {},
       ...latencyMs2 ? { latencyMs: latencyMs2 } : {},
-      ...existing.signal?.anomalous !== void 0 ? { anomalous: existing.signal.anomalous } : {}
+      ...existing.signal?.anomalous !== void 0 ? { anomalous: existing.signal.anomalous } : {},
+      ...lastError2 ? { lastError: lastError2 } : {}
     };
     const updated = {
       ...existing,
@@ -5711,12 +5735,14 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
   }
   const latencyHist = durationMs !== void 0 ? recordLatency({}, durationMs) : void 0;
   const latencyMs = latencyHist ? latencyPercentiles(latencyHist) : void 0;
+  const lastError = isError && errorDetail ? buildEdgeErrorExemplar(errorDetail, ts) : void 0;
   const signal = {
     spanCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedAgeMs: 0,
     ...latencyHist ? { latencyHist } : {},
-    ...latencyMs ? { latencyMs } : {}
+    ...latencyMs ? { latencyMs } : {},
+    ...lastError ? { lastError } : {}
   };
   const edge = {
     id,
@@ -6049,6 +6075,7 @@ async function handleSpan(ctx, span) {
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = spanRecordsError(span);
   const durationMs = span.durationNanos > 0n && !spanIsStreaming(span) ? Number(span.durationNanos) / 1e6 : void 0;
+  const errorDetail = isError ? edgeErrorDetailFromSpan(span) : void 0;
   const sourceServiceNode = ctx.graph.getNodeAttributes(sourceId);
   const callSite = callSiteFromSpan(span, sourceServiceNode, ctx.scanPath);
   cacheSpanService(span, nowMs, callSite);
@@ -6088,7 +6115,8 @@ async function handleSpan(ctx, span) {
         ts,
         isError,
         callSiteEvidence,
-        durationMs
+        durationMs,
+        errorDetail
       );
       if (result) affectedNode = targetId;
       if (span.dbSystem === "mongodb" && span.dbCollection) {
@@ -6101,7 +6129,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
       }
       if (span.dbTable) {
@@ -6114,7 +6143,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
         mergeObservedColumns(ctx.graph, tableId, span.dbColumns);
       }
@@ -6134,7 +6164,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else if (span.graphqlOperationName && span.graphqlOperationType && spanServesGraphqlOperation(span.kind)) {
@@ -6152,7 +6183,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else if (span.rpcSystem === "grpc" && span.rpcService && span.rpcMethod && spanServesGrpcMethod(span.kind)) {
@@ -6165,7 +6197,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else if (span.websocketChannel && spanServesWebsocketChannel(span.kind)) {
@@ -6182,7 +6215,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else {
@@ -6199,7 +6233,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
         affectedNode = targetId;
         resolvedViaAddress = true;
@@ -6213,7 +6248,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
         affectedNode = frontierNodeId;
         resolvedViaAddress = true;
@@ -6240,7 +6276,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           fallbackEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
       }
     }
@@ -6255,7 +6292,7 @@ async function handleSpan(ctx, span) {
     );
     if (routeNodeId) {
       const routeSvc = ctx.graph.getNodeAttributes(routeNodeId).service;
-      upsertObservedEdge(ctx.graph, import_types7.EdgeType.CONTAINS, (0, import_types7.serviceId)(routeSvc), routeNodeId, ts, isError, void 0, durationMs);
+      upsertObservedEdge(ctx.graph, import_types7.EdgeType.CONTAINS, (0, import_types7.serviceId)(routeSvc), routeNodeId, ts, isError, void 0, durationMs, errorDetail);
     }
   }
   if (span.statusCode === 2) {
@@ -8123,6 +8160,11 @@ function detectObservedFailingEdge(graph, bucket) {
       spanCount,
       errorCount,
       errorRate: clampConfidence(errorRate),
+      // The bounded last-error exemplar rides the finding as evidence (ADR-236):
+      // the error rate says HOW MUCH is failing, the exemplar says WHAT failed —
+      // a timeout vs a deadlock vs a connection-refused, which `errorCount`
+      // alone cannot name. Present only when the observed edge carries one.
+      ...signal.lastError ? { lastError: signal.lastError } : {},
       confidence: OBSERVED_FAILING_CONFIDENCE,
       reason: `Code declares ${bucket.source} \u2192 ${bucket.target} (${bucket.type}) and production observes it, but ${errorCount}/${spanCount} observed calls fail (${pct}% error rate) \u2014 the declared dependency is predominantly failing. The declared intent (EXTRACTED) and the observed behaviour (OBSERVED) diverge.`,
       recommendation: "Treat this as a broken declared dependency, not a coverage gap: production runs the call the code declares and most calls error. Check the dependency\u2019s health, recent deploys, and the observed error responses on this edge."
@@ -17598,10 +17640,11 @@ function locusOf(graph, ev) {
   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;
+  const symbol = node?.type === "SymbolNode" ? node.qualname : void 0;
   return {
     file,
     ...Number.isFinite(line) ? { lineStart: line, lineEnd: line } : {},
-    ...node?.name ? { symbol: node.name } : {},
+    ...symbol ? { symbol } : {},
     service: node?.service ?? ev.service,
     provenance: import_types60.Provenance.OBSERVED
   };
@@ -17697,7 +17740,8 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
   const policyCards = applicable.map((p) => ({
     policyName: p.policyName,
     severity: p.severity,
-    message: p.reason
+    message: p.reason,
+    onViolation: p.onViolation
   }));
   const divergences = inGraph ? computeDivergences(graph, { node: affected, incidents }).divergences.map((d) => ({
     type: d.type,
@@ -17724,8 +17768,111 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
     ...divergences.length > 0 ? { divergence: divergences } : {},
     headline: renderHeadline(graph, errorEvent, locus, rootCause?.node ?? null)
   };
+  card.grade = gradeIncidentCard(card);
   return import_types60.IncidentCardSchema.parse(card);
 }
+var GRADE_PRIORS_VERSION = "sniper-architecture-priors-2026-10-08";
+var GRADE_WEIGHTS = {
+  evidence: 3,
+  locus: 2,
+  tests: 2,
+  reach: 1.5,
+  kind: 1.5,
+  chain: 1,
+  recur: 1,
+  div: 1
+};
+var PROVENANCE_WEIGHT = {
+  OBSERVED: 1,
+  EXTRACTED: 0.8,
+  INFERRED: 0.4,
+  FRONTIER: 0.3,
+  STALE: 0.2
+};
+var REACH_NODES_MAX = 50;
+var TIMEOUT = /timeout|timed out|deadline/i;
+var round2 = (n) => Math.round(n * 1e4) / 1e4;
+function factor(name, value, evidence, reason) {
+  return {
+    value: value === null ? null : round2(value),
+    weight: GRADE_WEIGHTS[name],
+    evidence,
+    ...reason ? { reason } : {}
+  };
+}
+function gradeIncidentCard(card) {
+  const rc = card.rootCause;
+  const chain = rc?.chain ?? [];
+  const gates = {
+    policyNotBlock: {
+      passed: !(card.policies ?? []).some((p) => p.onViolation === "block"),
+      evidence: ["policies[].onViolation"]
+    },
+    notSymptomOnly: {
+      passed: rc?.classification !== "symptom-only",
+      evidence: ["rootCause.classification"]
+    },
+    locusResolves: { passed: card.locus !== null, evidence: ["locus"] }
+  };
+  const gamma = Object.values(gates).every((g) => g.passed) ? 1 : 0;
+  const carrying = chain.some((h) => h.carriesSignal === true) ? chain.filter((h) => h.carriesSignal === true) : chain;
+  const hopWeights = carrying.map((h) => PROVENANCE_WEIGHT[h.provenance]);
+  const evidence = hopWeights.length === 0 ? factor("evidence", null, ["rootCause.chain[].provenance"], "no root-cause chain on the card") : hopWeights.some((w) => w === void 0) ? factor("evidence", null, ["rootCause.chain[].provenance"], "a chain hop has a provenance with no weight") : factor("evidence", Math.min(...hopWeights), ["rootCause.chain[].provenance"]);
+  const locus = card.locus ? factor("locus", card.locus.symbol ? 1 : 0.6, ["locus.symbol", "locus.file"]) : factor("locus", null, ["locus"], "no locus on the card (the locus gate fails)");
+  const tests = factor(
+    "tests",
+    null,
+    [],
+    "the card carries no test-file classification or test-to-symbol edges"
+  );
+  const reach = card.blastRadius ? factor(
+    "reach",
+    Math.max(0, 1 - card.blastRadius.totalAffected / REACH_NODES_MAX),
+    ["blastRadius.totalAffected"],
+    `nodes in the blast radius against a prior bound of ${REACH_NODES_MAX}`
+  ) : factor("reach", null, ["blastRadius"], "no blast radius on the card");
+  const timeout = TIMEOUT.test(`${card.exceptionType ?? ""} ${card.message}`);
+  const kindValue = timeout ? 0.3 : card.incidentKind === "exception" ? 1 : card.incidentKind === "5xx" || card.incidentKind === "status-error" ? 0.7 : card.incidentKind === "connector" ? 0.6 : 0.4;
+  const kind = factor("kind", kindValue, ["incidentKind", "exceptionType", "message"]);
+  const chainFactor = rc ? factor(
+    "chain",
+    1 / (1 + 0.25 * (Math.max(1, chain.length - 1) - 1)),
+    ["rootCause.chain"]
+  ) : factor("chain", null, ["rootCause"], "no root cause on the card");
+  const occurrences = card.count ?? 1;
+  const recurValue = Math.min(1, Math.log(1 + occurrences) / Math.log(11));
+  const recur = factor(
+    "recur",
+    recurValue,
+    ["count"],
+    card.count === void 0 ? "no coalesced count; one recorded occurrence" : void 0
+  );
+  const div = factor("div", (card.divergence ?? []).length > 0 ? 1 : 0.7, ["divergence"]);
+  const factors = { evidence, locus, tests, reach, kind, chain: chainFactor, recur, div };
+  let weighted = 0;
+  let total = 0;
+  for (const f of Object.values(factors)) {
+    if (f.value === null) continue;
+    weighted += f.weight * f.value;
+    total += f.weight;
+  }
+  const C = round2(weighted / total);
+  const G = round2(gamma * C);
+  const band = gamma === 0 || G < 0.5 ? "out" : G >= 0.75 ? "full" : "diagnose-only";
+  return {
+    G,
+    gamma,
+    gates,
+    C,
+    factors,
+    band,
+    urgency: {
+      value: null,
+      reason: "f_fresh needs the time of the last OBSERVED signal at the node, which the card does not carry"
+    },
+    priorsVersion: GRADE_PRIORS_VERSION
+  };
+}
 
 // src/ask.ts
 init_cjs_shims();
@@ -19498,7 +19645,7 @@ async function computePrVerdict(req, ctx, deps, deadline) {
       const found = observedBreakFrom(node, getObservedDependencies(ctx.liveGraph, node.id));
       if (found) observedBreaks.push(found);
     }
-    const { marker, body } = renderVerdict({
+    const { marker, body: rendered } = renderVerdict({
       graph: head,
       delta,
       changedFiles,
@@ -19506,6 +19653,7 @@ async function computePrVerdict(req, ctx, deps, deadline) {
       observedBreaks,
       tone: req.tone ?? "loud"
     });
+    const body = rendered.startsWith(marker) ? rendered.slice(marker.length).replace(/^(?:\r?\n)+/, "") : rendered;
     return {
       marker,
       body,
@@ -24403,13 +24551,25 @@ async function makeTransformersEmbedder() {
     }
   };
 }
-async function pickEmbedder() {
-  const host = ollamaHost();
-  if (host && await ollamaReachable(host)) {
-    return makeOllamaEmbedder(host);
+async function pickEmbedder(provider) {
+  if (provider !== "transformers") {
+    const host = ollamaHost();
+    if (host && await ollamaReachable(host)) {
+      return makeOllamaEmbedder(host);
+    }
   }
+  if (provider === "ollama") return null;
   return makeTransformersEmbedder();
 }
+function searchProviderFromEnv(env = process.env, warn = console.warn) {
+  const value = env.NEAT_SEARCH_PROVIDER;
+  if (!value) return void 0;
+  if (value === "substring" || value === "ollama" || value === "transformers") return value;
+  warn(
+    `semantic_search: NEAT_SEARCH_PROVIDER="${value}" is not substring, ollama, or transformers; using automatic selection`
+  );
+  return void 0;
+}
 async function readCache(cachePath) {
   try {
     const raw = await import_node_fs44.promises.readFile(cachePath, "utf8");
@@ -24573,7 +24733,8 @@ async function buildSearchIndex(graph, options = {}) {
   if (options.embedder) {
     embedder = options.embedder;
   } else if (options.forceProvider !== "substring") {
-    const factory = options.embedderFactory ?? pickEmbedder;
+    const forcedProvider = options.forceProvider;
+    const factory = options.embedderFactory ?? (() => pickEmbedder(forcedProvider));
     embedder = await resolveEmbedderBounded(
       factory,
       options.initTimeoutMs ?? searchInitTimeoutMs()
@@ -24617,7 +24778,8 @@ async function bootProject(registry, name, scanPath, baseDir) {
   startPersistLoop(graph, paths.snapshotPath);
   startStalenessLoop(graph, { staleEventsPath: paths.staleEventsPath });
   const searchIndex = await buildSearchIndex(graph, {
-    cachePath: paths.embeddingsCachePath
+    cachePath: paths.embeddingsCachePath,
+    forceProvider: searchProviderFromEnv()
   }).catch((err) => {
     console.warn(
       `[${name}] semantic_search: index build failed (${err.message}); falling back to inline substring`