@neat.is/core 0.3.3 → 0.3.5

package/dist/index.cjs

@@ -100,8 +100,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path33.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path33.default.resolve(here, "..", "proto");
+  const here = import_node_path34.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path34.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -156,13 +156,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path33, grpc, protoLoader;
+var import_node_url, import_node_path34, grpc, protoLoader;
 var init_otel_grpc = __esm({
   "src/otel-grpc.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_url = require("url");
-    import_node_path33 = __toESM(require("path"), 1);
+    import_node_path34 = __toESM(require("path"), 1);
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
     init_otel();
@@ -259,10 +259,10 @@ function parseOtlpRequest(body) {
 }
 function loadProtobufDecoder() {
   if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
-  const here = import_node_path34.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path34.default.resolve(here, "..", "proto");
+  const here = import_node_path35.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path35.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path34.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path35.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -362,12 +362,12 @@ function logSpanHandler(span) {
     `otel: ${span.service} ${span.name} parent=${parent} status=${status2}${db}`
   );
 }
-var import_node_path34, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
+var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path34 = __toESM(require("path"), 1);
+    import_node_path35 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
@@ -794,11 +794,16 @@ init_cjs_shims();
 var import_types = require("@neat.is/types");
 var ROOT_CAUSE_MAX_DEPTH = 5;
 var BLAST_RADIUS_DEFAULT_DEPTH = 10;
+function isFrontierNode(graph, nodeId) {
+  if (!graph.hasNode(nodeId)) return false;
+  const attrs = graph.getNodeAttributes(nodeId);
+  return attrs.type === import_types.NodeType.FrontierNode;
+}
 function bestEdgeBySource(graph, edgeIds) {
   const best = /* @__PURE__ */ new Map();
   for (const id of edgeIds) {
     const e = graph.getEdgeAttributes(id);
-    if (e.provenance === import_types.Provenance.FRONTIER) continue;
+    if (isFrontierNode(graph, e.source)) continue;
     const cur = best.get(e.source);
     if (!cur || import_types.PROV_RANK[e.provenance] > import_types.PROV_RANK[cur.provenance]) {
       best.set(e.source, e);
@@ -810,7 +815,7 @@ function bestEdgeByTarget(graph, edgeIds) {
   const best = /* @__PURE__ */ new Map();
   for (const id of edgeIds) {
     const e = graph.getEdgeAttributes(id);
-    if (e.provenance === import_types.Provenance.FRONTIER) continue;
+    if (isFrontierNode(graph, e.target)) continue;
     const cur = best.get(e.target);
     if (!cur || import_types.PROV_RANK[e.provenance] > import_types.PROV_RANK[cur.provenance]) {
       best.set(e.target, e);
@@ -822,8 +827,7 @@ var PROVENANCE_CEILING = {
   OBSERVED: 1,
   INFERRED: 0.7,
   EXTRACTED: 0.5,
-  STALE: 0.3,
-  FRONTIER: 0.3
+  STALE: 0.3
 };
 function volumeWeight(spanCount) {
   if (!spanCount || spanCount <= 0) return 0.5;
@@ -876,19 +880,19 @@ function confidenceFromMix(edges, now = Date.now()) {
 function longestIncomingWalk(graph, start, maxDepth) {
   let best = { path: [start], edges: [] };
   const visited = /* @__PURE__ */ new Set([start]);
-  function step(node, path36, edges) {
-    if (path36.length > best.path.length) {
-      best = { path: [...path36], edges: [...edges] };
+  function step(node, path37, edges) {
+    if (path37.length > best.path.length) {
+      best = { path: [...path37], edges: [...edges] };
     }
-    if (path36.length - 1 >= maxDepth) return;
+    if (path37.length - 1 >= maxDepth) return;
     const incoming = bestEdgeBySource(graph, graph.inboundEdges(node));
     for (const [srcId, edge] of incoming) {
       if (visited.has(srcId)) continue;
       visited.add(srcId);
-      path36.push(srcId);
+      path37.push(srcId);
       edges.push(edge);
-      step(srcId, path36, edges);
-      path36.pop();
+      step(srcId, path37, edges);
+      path37.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -1107,8 +1111,8 @@ var evaluateStructural = ({
     for (const edgeId of graph.outboundEdges(id)) {
       const e = graph.getEdgeAttributes(edgeId);
       if (e.type !== rule.edgeType) continue;
-      if (e.provenance === import_types2.Provenance.FRONTIER) continue;
       const target = graph.getNodeAttributes(e.target);
+      if (target.type === import_types2.NodeType.FrontierNode) continue;
       if (target.type === rule.toNodeType) {
         satisfied = true;
         break;
@@ -1227,8 +1231,8 @@ var evaluateCompatibility = ({
       for (const edgeId of graph.outboundEdges(svcId)) {
         const e = graph.getEdgeAttributes(edgeId);
         if (e.type !== import_types2.EdgeType.CONNECTS_TO) continue;
-        if (e.provenance === import_types2.Provenance.FRONTIER) continue;
         const dbAttrs = graph.getNodeAttributes(e.target);
+        if (dbAttrs.type === import_types2.NodeType.FrontierNode) continue;
         if (dbAttrs.type !== import_types2.NodeType.DatabaseNode) continue;
         const db = dbAttrs;
         for (const pair of compatPairs()) {
@@ -1545,31 +1549,6 @@ function ensureFrontierNode(graph, host, ts) {
   graph.addNode(id, node);
   return id;
 }
-function upsertFrontierEdge(graph, type, source, target, ts) {
-  const id = (0, import_types3.frontierEdgeId)(source, target, type);
-  if (graph.hasEdge(id)) {
-    const existing = graph.getEdgeAttributes(id);
-    const updated = {
-      ...existing,
-      provenance: import_types3.Provenance.FRONTIER,
-      lastObserved: ts,
-      callCount: (existing.callCount ?? 0) + 1
-    };
-    graph.replaceEdgeAttributes(id, updated);
-    return;
-  }
-  const edge = {
-    id,
-    source,
-    target,
-    type,
-    provenance: import_types3.Provenance.FRONTIER,
-    confidence: 1,
-    lastObserved: ts,
-    callCount: 1
-  };
-  graph.addEdgeWithKey(id, source, target, edge);
-}
 function upsertObservedEdge(graph, type, source, target, ts, isError = false) {
   if (!graph.hasNode(source) || !graph.hasNode(target)) return null;
   const id = makeObservedEdgeId(type, source, target);
@@ -1577,35 +1556,37 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false) {
     const existing = graph.getEdgeAttributes(id);
     const newSpanCount = (existing.signal?.spanCount ?? existing.callCount ?? 0) + 1;
     const newErrorCount = (existing.signal?.errorCount ?? 0) + (isError ? 1 : 0);
+    const newSignal = {
+      spanCount: newSpanCount,
+      errorCount: newErrorCount,
+      lastObservedAgeMs: 0
+    };
     const updated = {
       ...existing,
       provenance: import_types3.Provenance.OBSERVED,
       lastObserved: ts,
       callCount: newSpanCount,
-      signal: {
-        spanCount: newSpanCount,
-        errorCount: newErrorCount,
-        lastObservedAgeMs: 0
-      },
-      confidence: 1
+      signal: newSignal,
+      confidence: (0, import_types3.confidenceForObservedSignal)(newSignal)
     };
     graph.replaceEdgeAttributes(id, updated);
     return { edge: updated, created: false };
   }
+  const signal = {
+    spanCount: 1,
+    errorCount: isError ? 1 : 0,
+    lastObservedAgeMs: 0
+  };
   const edge = {
     id,
     source,
     target,
     type,
     provenance: import_types3.Provenance.OBSERVED,
-    confidence: 1,
+    confidence: (0, import_types3.confidenceForObservedSignal)(signal),
     lastObserved: ts,
     callCount: 1,
-    signal: {
-      spanCount: 1,
-      errorCount: isError ? 1 : 0,
-      lastObservedAgeMs: 0
-    }
+    signal
   };
   graph.addEdgeWithKey(id, source, target, edge);
   return { edge, created: true };
@@ -1653,18 +1634,28 @@ async function appendErrorEvent(ctx, ev) {
   await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(ctx.errorsPath), { recursive: true });
   await import_node_fs3.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
+function sanitizeAttributes(attrs) {
+  const out = {};
+  for (const [k, v] of Object.entries(attrs)) {
+    if (typeof v === "bigint") out[k] = v.toString();
+    else out[k] = v;
+  }
+  return out;
+}
 function buildErrorEventForReceiver(span) {
   if (span.statusCode !== 2) return null;
   const ts = span.startTimeIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const attrs = sanitizeAttributes(span.attributes);
   return {
     id: `${span.traceId}:${span.spanId}`,
     timestamp: ts,
     service: span.service,
     traceId: span.traceId,
     spanId: span.spanId,
-    errorMessage: span.exception?.message ?? span.errorMessage ?? span.name ?? "unknown error",
+    errorMessage: span.exception?.message ?? span.name ?? "unknown error",
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+    ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
     affectedNode: (0, import_types3.serviceId)(span.service)
   };
 }
@@ -1715,11 +1706,16 @@ async function handleSpan(ctx, span) {
         affectedNode = targetId;
         resolvedViaAddress = true;
       } else if (!targetId) {
-        const frontierId2 = ensureFrontierNode(ctx.graph, host, ts);
-        if (ctx.graph.hasNode(sourceId)) {
-          upsertFrontierEdge(ctx.graph, import_types3.EdgeType.CALLS, sourceId, frontierId2, ts);
-        }
-        affectedNode = frontierId2;
+        const frontierNodeId = ensureFrontierNode(ctx.graph, host, ts);
+        upsertObservedEdge(
+          ctx.graph,
+          import_types3.EdgeType.CALLS,
+          sourceId,
+          frontierNodeId,
+          ts,
+          isError
+        );
+        affectedNode = frontierNodeId;
         resolvedViaAddress = true;
       }
     }
@@ -1741,15 +1737,17 @@ async function handleSpan(ctx, span) {
   if (span.statusCode === 2) {
     stitchTrace(ctx.graph, sourceId, ts);
     if (ctx.writeErrorEventInline !== false) {
+      const attrs = sanitizeAttributes(span.attributes);
       const ev = {
         id: `${span.traceId}:${span.spanId}`,
         timestamp: ts,
         service: span.service,
         traceId: span.traceId,
         spanId: span.spanId,
-        errorMessage: span.exception?.message ?? span.errorMessage ?? span.name ?? "unknown error",
+        errorMessage: span.exception?.message ?? span.name ?? "unknown error",
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
+        ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
         affectedNode
       };
       await appendErrorEvent(ctx, ev);
@@ -1805,8 +1803,7 @@ function rewireFrontierEdges(graph, frontierId2, serviceId3) {
 }
 function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
   graph.dropEdge(oldEdgeId);
-  const promotedProvenance = edge.provenance === import_types3.Provenance.FRONTIER ? import_types3.Provenance.OBSERVED : edge.provenance;
-  const newId = promotedProvenance === import_types3.Provenance.OBSERVED ? (0, import_types3.observedEdgeId)(newSource, newTarget, edge.type) : promotedProvenance === import_types3.Provenance.INFERRED ? (0, import_types3.inferredEdgeId)(newSource, newTarget, edge.type) : promotedProvenance === import_types3.Provenance.EXTRACTED ? (0, import_types3.extractedEdgeId)(newSource, newTarget, edge.type) : (0, import_types3.frontierEdgeId)(newSource, newTarget, edge.type);
+  const newId = edge.provenance === import_types3.Provenance.OBSERVED ? (0, import_types3.observedEdgeId)(newSource, newTarget, edge.type) : edge.provenance === import_types3.Provenance.INFERRED ? (0, import_types3.inferredEdgeId)(newSource, newTarget, edge.type) : (0, import_types3.extractedEdgeId)(newSource, newTarget, edge.type);
   if (graph.hasEdge(newId)) {
     const existing = graph.getEdgeAttributes(newId);
     const merged = {
@@ -1821,8 +1818,7 @@ function rebuildEdge(graph, edge, newSource, newTarget, oldEdgeId) {
     ...edge,
     id: newId,
     source: newSource,
-    target: newTarget,
-    provenance: promotedProvenance
+    target: newTarget
   };
   graph.addEdgeWithKey(newId, newSource, newTarget, rebuilt);
 }
@@ -2232,6 +2228,23 @@ async function writeExtractionErrors(errors, errorsPath) {
   const lines = errors.map((e) => JSON.stringify(e)).join("\n") + "\n";
   await import_node_fs7.promises.appendFile(errorsPath, lines, "utf8");
 }
+var droppedSink = [];
+function noteExtractedDropped(edge) {
+  droppedSink.push(edge);
+}
+function drainDroppedExtracted() {
+  return droppedSink.splice(0, droppedSink.length);
+}
+function isRejectedLogEnabled() {
+  const raw = process.env.NEAT_EXTRACTED_REJECTED_LOG;
+  return raw === "1" || raw === "true";
+}
+async function writeRejectedExtracted(drops, rejectedPath) {
+  if (drops.length === 0) return;
+  await import_node_fs7.promises.mkdir(import_node_path7.default.dirname(rejectedPath), { recursive: true });
+  const lines = drops.map((d) => JSON.stringify({ ...d, ts: (/* @__PURE__ */ new Date()).toISOString() })).join("\n") + "\n";
+  await import_node_fs7.promises.appendFile(rejectedPath, lines, "utf8");
+}
 
 // src/extract/services.ts
 var DEFAULT_SCAN_DEPTH = 5;
@@ -3170,6 +3183,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
         target: dbNode.id,
         type: import_types7.EdgeType.CONNECTS_TO,
         provenance: import_types7.Provenance.EXTRACTED,
+        confidence: (0, import_types7.confidenceForExtracted)("structural"),
         // ADR-032 / #140 — every EXTRACTED edge carries evidence.file.
         // Ghost-edge cleanup keys retirement on this; the conditional
         // sourceFile spread that used to live here was a v0.1.x leftover.
@@ -3244,6 +3258,7 @@ async function addConfigNodes(graph, services, scanPath) {
         target: node.id,
         type: import_types8.EdgeType.CONFIGURED_BY,
         provenance: import_types8.Provenance.EXTRACTED,
+        confidence: (0, import_types8.confidenceForExtracted)("structural"),
         evidence: { file: relPath.split(import_node_path18.default.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
@@ -3398,17 +3413,32 @@ async function addHttpCallEdges(graph, services) {
     for (const [targetId, evidenceFile] of seenTargets) {
       const fileContent = files.find((f) => f.path === evidenceFile.file)?.content ?? "";
       const line = lineOf(fileContent, `//${evidenceFile.host}`);
+      const confidence = (0, import_types9.confidenceForExtracted)("hostname-shape-match");
+      const ev = {
+        file: import_node_path20.default.relative(service.dir, evidenceFile.file),
+        line,
+        snippet: snippet(fileContent, line)
+      };
+      const edgeId = (0, import_types4.extractedEdgeId)(service.node.id, targetId, import_types9.EdgeType.CALLS);
+      if (!(0, import_types9.passesExtractedFloor)(confidence)) {
+        noteExtractedDropped({
+          source: service.node.id,
+          target: targetId,
+          type: import_types9.EdgeType.CALLS,
+          confidence,
+          confidenceKind: "hostname-shape-match",
+          evidence: ev
+        });
+        continue;
+      }
       const edge = {
-        id: (0, import_types4.extractedEdgeId)(service.node.id, targetId, import_types9.EdgeType.CALLS),
+        id: edgeId,
         source: service.node.id,
         target: targetId,
         type: import_types9.EdgeType.CALLS,
         provenance: import_types9.Provenance.EXTRACTED,
-        evidence: {
-          file: import_node_path20.default.relative(service.dir, evidenceFile.file),
-          line,
-          snippet: snippet(fileContent, line)
-        }
+        confidence,
+        evidence: ev
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -3447,6 +3477,10 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       name: topic,
       kind: "kafka-topic",
       edgeType,
+      // `producer.send({topic: 'x'})` / `consumer.subscribe({topic: 'x'})` —
+      // framework-aware (kafkajs / node-rdkafka shape). Verified-call-site
+      // tier (ADR-066).
+      confidenceKind: "verified-call-site",
       evidence: {
         file: import_node_path21.default.relative(serviceDir, file.path),
         line,
@@ -3479,6 +3513,10 @@ function redisEndpointsFromFile(file, serviceDir) {
       name: host,
       kind: "redis",
       edgeType: "CALLS",
+      // `redis://host` URL literal — the scheme is structural support, but no
+      // call expression is verified to wire it through. URL-with-structural-
+      // support tier (ADR-066).
+      confidenceKind: "url-with-structural-support",
       evidence: {
         file: import_node_path22.default.relative(serviceDir, file.path),
         line,
@@ -3520,6 +3558,10 @@ function awsEndpointsFromFile(file, serviceDir) {
       name,
       kind,
       edgeType: "CALLS",
+      // SDK marker (S3Client, GetCommand, etc.) plus a Bucket/TableName
+      // literal — framework-aware recognizer, verified-call-site tier
+      // (ADR-066).
+      confidenceKind: "verified-call-site",
       evidence: {
         file: import_node_path23.default.relative(serviceDir, file.path),
         line,
@@ -3599,6 +3641,10 @@ function grpcEndpointsFromFile(file, serviceDir) {
       name,
       kind,
       edgeType: "CALLS",
+      // `new <Name>Client(...)` with @aws-sdk/* or @grpc/grpc-js import
+      // context — import-aware classification per #238. Verified-call-site
+      // tier (ADR-066).
+      confidenceKind: "verified-call-site",
       evidence: {
         file: import_node_path24.default.relative(serviceDir, file.path),
         line,
@@ -3659,6 +3705,18 @@ async function addExternalEndpointEdges(graph, services) {
       const edgeId = (0, import_types4.extractedEdgeId)(service.node.id, ep.infraId, edgeType);
       if (seenEdges.has(edgeId)) continue;
       seenEdges.add(edgeId);
+      const confidence = (0, import_types14.confidenceForExtracted)(ep.confidenceKind);
+      if (!(0, import_types14.passesExtractedFloor)(confidence)) {
+        noteExtractedDropped({
+          source: service.node.id,
+          target: ep.infraId,
+          type: edgeType,
+          confidence,
+          confidenceKind: ep.confidenceKind,
+          evidence: ep.evidence
+        });
+        continue;
+      }
       if (!graph.hasEdge(edgeId)) {
         const edge = {
           id: edgeId,
@@ -3666,6 +3724,7 @@ async function addExternalEndpointEdges(graph, services) {
           target: ep.infraId,
           type: edgeType,
           provenance: import_types14.Provenance.EXTRACTED,
+          confidence,
           evidence: ep.evidence
         };
         graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -3785,6 +3844,7 @@ async function addComposeInfra(graph, scanPath, services) {
         target: targetId,
         type: import_types16.EdgeType.DEPENDS_ON,
         provenance: import_types16.Provenance.EXTRACTED,
+        confidence: (0, import_types16.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -3845,6 +3905,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
         target: node.id,
         type: import_types17.EdgeType.RUNS_ON,
         provenance: import_types17.Provenance.EXTRACTED,
+        confidence: (0, import_types17.confidenceForExtracted)("structural"),
         evidence: {
           file: import_node_path26.default.relative(scanPath, dockerfilePath).split(import_node_path26.default.sep).join("/")
         }
@@ -3961,6 +4022,9 @@ async function addInfra(graph, scanPath, services) {
   };
 }
 
+// src/extract/index.ts
+var import_node_path30 = __toESM(require("path"), 1);
+
 // src/extract/retire.ts
 init_cjs_shims();
 var import_node_fs17 = require("fs");
@@ -4013,13 +4077,26 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
       );
     }
   }
+  const droppedEntries = drainDroppedExtracted();
+  if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
+    const rejectedPath = import_node_path30.default.join(import_node_path30.default.dirname(opts.errorsPath), "rejected.ndjson");
+    try {
+      await writeRejectedExtracted(droppedEntries, rejectedPath);
+    } catch (err) {
+      console.warn(
+        `[neat] failed to write rejected extracted edges to ${rejectedPath}: ${err.message}`
+      );
+    }
+  }
   const result = {
     nodesAdded: phase1Nodes + phase2.nodesAdded + phase3.nodesAdded + phase4.nodesAdded + phase5.nodesAdded,
     edgesAdded: phase2.edgesAdded + phase3.edgesAdded + phase4.edgesAdded + phase5.edgesAdded,
     frontiersPromoted,
     extractionErrors: errorEntries.length,
     errorEntries,
-    ghostsRetired
+    ghostsRetired,
+    extractedDropped: droppedEntries.length,
+    droppedEntries
   };
   emitNeatEvent({
     type: "extraction-complete",
@@ -4037,8 +4114,9 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 // src/persist.ts
 init_cjs_shims();
 var import_node_fs18 = require("fs");
-var import_node_path30 = __toESM(require("path"), 1);
-var SCHEMA_VERSION = 2;
+var import_node_path31 = __toESM(require("path"), 1);
+var import_types19 = require("@neat.is/types");
+var SCHEMA_VERSION = 3;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
   if (Array.isArray(nodes)) {
@@ -4050,8 +4128,27 @@ function migrateV1ToV2(payload) {
   }
   return { ...payload, schemaVersion: 2 };
 }
+function migrateV2ToV3(payload) {
+  const edges = payload.graph.edges;
+  if (Array.isArray(edges)) {
+    for (const edge of edges) {
+      const attrs = edge.attributes;
+      if (!attrs || attrs.provenance !== "FRONTIER") continue;
+      attrs.provenance = import_types19.Provenance.OBSERVED;
+      const type = typeof attrs.type === "string" ? attrs.type : void 0;
+      const source = typeof attrs.source === "string" ? attrs.source : void 0;
+      const target = typeof attrs.target === "string" ? attrs.target : void 0;
+      if (type && source && target) {
+        const newId = (0, import_types19.observedEdgeId)(source, target, type);
+        attrs.id = newId;
+        if (edge.key) edge.key = newId;
+      }
+    }
+  }
+  return { ...payload, schemaVersion: 3 };
+}
 async function ensureDir(filePath) {
-  await import_node_fs18.promises.mkdir(import_node_path30.default.dirname(filePath), { recursive: true });
+  await import_node_fs18.promises.mkdir(import_node_path31.default.dirname(filePath), { recursive: true });
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -4076,6 +4173,9 @@ async function loadGraphFromDisk(graph, outPath) {
   if (payload.schemaVersion === 1) {
     payload = migrateV1ToV2(payload);
   }
+  if (payload.schemaVersion === 2) {
+    payload = migrateV2ToV3(payload);
+  }
   if (payload.schemaVersion !== SCHEMA_VERSION) {
     throw new Error(
       `persist: unsupported snapshot schemaVersion ${payload.schemaVersion} (expected ${SCHEMA_VERSION})`
@@ -4122,11 +4222,11 @@ function startPersistLoop(graph, outPath, intervalMs = 6e4) {
 init_cjs_shims();
 var import_fastify = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types21 = require("@neat.is/types");
+var import_types22 = require("@neat.is/types");
 
 // src/divergences.ts
 init_cjs_shims();
-var import_types19 = require("@neat.is/types");
+var import_types20 = require("@neat.is/types");
 function bucketKey(source, target, type) {
   return `${type}|${source}|${target}`;
 }
@@ -4134,25 +4234,22 @@ function bucketEdges(graph) {
   const buckets = /* @__PURE__ */ new Map();
   graph.forEachEdge((id, attrs) => {
     const e = attrs;
-    const parsed = (0, import_types19.parseEdgeId)(id);
+    const parsed = (0, import_types20.parseEdgeId)(id);
     const provenance = parsed?.provenance ?? e.provenance;
     const key = bucketKey(e.source, e.target, e.type);
     const cur = buckets.get(key) ?? { source: e.source, target: e.target, type: e.type };
     switch (provenance) {
-      case import_types19.Provenance.EXTRACTED:
+      case import_types20.Provenance.EXTRACTED:
         cur.extracted = e;
         break;
-      case import_types19.Provenance.OBSERVED:
+      case import_types20.Provenance.OBSERVED:
         cur.observed = e;
         break;
-      case import_types19.Provenance.INFERRED:
+      case import_types20.Provenance.INFERRED:
         cur.inferred = e;
         break;
-      case import_types19.Provenance.FRONTIER:
-        cur.frontier = e;
-        break;
       default:
-        if (e.provenance === import_types19.Provenance.STALE) cur.stale = e;
+        if (e.provenance === import_types20.Provenance.STALE) cur.stale = e;
     }
     buckets.set(key, cur);
   });
@@ -4161,15 +4258,7 @@ function bucketEdges(graph) {
 function nodeIsFrontier(graph, nodeId) {
   if (!graph.hasNode(nodeId)) return false;
   const attrs = graph.getNodeAttributes(nodeId);
-  return attrs.type === import_types19.NodeType.FrontierNode;
-}
-function hasAnyObservedFromSource(graph, sourceId) {
-  if (!graph.hasNode(sourceId)) return false;
-  for (const edgeId of graph.outboundEdges(sourceId)) {
-    const e = graph.getEdgeAttributes(edgeId);
-    if (e.provenance === import_types19.Provenance.OBSERVED) return true;
-  }
-  return false;
+  return attrs.type === import_types20.NodeType.FrontierNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -4184,32 +4273,34 @@ function reasonForMissingExtracted(source, target, type) {
 var RECOMMENDATION_MISSING_OBSERVED = "Verify the code path is exercised in production; check feature flags or conditional branches that might gate the call.";
 var RECOMMENDATION_MISSING_EXTRACTED = "Likely dynamic dispatch, reflection, or a coverage gap in tree-sitter extraction. Consider an `aliases` entry on the source service or file an extractor issue.";
 var RECOMMENDATION_HOST_MISMATCH = "Check environment-specific config overrides \u2014 the runtime host differs from what static configuration declares.";
+function gradedConfidence(edge) {
+  if (typeof edge.confidence === "number") return clampConfidence(edge.confidence);
+  return clampConfidence(confidenceForEdge(edge));
+}
 function detectMissingDivergences(graph, bucket) {
   const out = [];
   if (bucket.extracted && !bucket.observed) {
     if (!nodeIsFrontier(graph, bucket.target)) {
-      const sourceHasTraffic = hasAnyObservedFromSource(graph, bucket.source);
       out.push({
         type: "missing-observed",
         source: bucket.source,
         target: bucket.target,
         edgeType: bucket.type,
         extracted: bucket.extracted,
-        confidence: sourceHasTraffic ? 1 : 0.5,
+        confidence: gradedConfidence(bucket.extracted),
         reason: reasonForMissingObserved(bucket.source, bucket.target, bucket.type),
         recommendation: RECOMMENDATION_MISSING_OBSERVED
       });
     }
   }
   if (bucket.observed && !bucket.extracted) {
-    const cascaded = clampConfidence(confidenceForEdge(bucket.observed));
     out.push({
       type: "missing-extracted",
       source: bucket.source,
       target: bucket.target,
       edgeType: bucket.type,
       observed: bucket.observed,
-      confidence: cascaded,
+      confidence: gradedConfidence(bucket.observed),
       reason: reasonForMissingExtracted(bucket.source, bucket.target, bucket.type),
       recommendation: RECOMMENDATION_MISSING_EXTRACTED
     });
@@ -4228,7 +4319,7 @@ function declaredHostFor(svc) {
 function hasExtractedConfiguredBy(graph, svcId) {
   for (const edgeId of graph.outboundEdges(svcId)) {
     const e = graph.getEdgeAttributes(edgeId);
-    if (e.type === import_types19.EdgeType.CONFIGURED_BY && e.provenance === import_types19.Provenance.EXTRACTED) {
+    if (e.type === import_types20.EdgeType.CONFIGURED_BY && e.provenance === import_types20.Provenance.EXTRACTED) {
       return true;
     }
   }
@@ -4241,10 +4332,10 @@ function detectHostMismatch(graph, svcId, svc) {
   const out = [];
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types19.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types19.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types20.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types20.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types19.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types20.NodeType.DatabaseNode) continue;
     const observedHost = target.host?.trim();
     if (!observedHost) continue;
     if (observedHost === declaredHost) continue;
@@ -4266,10 +4357,10 @@ function detectCompatDivergences(graph, svcId, svc) {
   const deps = svc.dependencies ?? {};
   for (const edgeId of graph.outboundEdges(svcId)) {
     const edge = graph.getEdgeAttributes(edgeId);
-    if (edge.type !== import_types19.EdgeType.CONNECTS_TO) continue;
-    if (edge.provenance !== import_types19.Provenance.OBSERVED) continue;
+    if (edge.type !== import_types20.EdgeType.CONNECTS_TO) continue;
+    if (edge.provenance !== import_types20.Provenance.OBSERVED) continue;
     const target = graph.getNodeAttributes(edge.target);
-    if (target.type !== import_types19.NodeType.DatabaseNode) continue;
+    if (target.type !== import_types20.NodeType.DatabaseNode) continue;
     for (const pair of compatPairs()) {
       if (pair.engine !== target.engine) continue;
       const declared = deps[pair.driver];
@@ -4330,7 +4421,7 @@ function computeDivergences(graph, opts = {}) {
   }
   graph.forEachNode((nodeId, attrs) => {
     const n = attrs;
-    if (n.type !== import_types19.NodeType.ServiceNode) return;
+    if (n.type !== import_types20.NodeType.ServiceNode) return;
     const svc = n;
     for (const d of detectHostMismatch(graph, nodeId, svc)) all.push(d);
     for (const d of detectCompatDivergences(graph, nodeId, svc)) all.push(d);
@@ -4348,13 +4439,22 @@ function computeDivergences(graph, opts = {}) {
     const target = opts.node;
     filtered = filtered.filter((d) => involvesNode(d, target));
   }
+  const TYPE_LEADERSHIP = {
+    "missing-extracted": 0,
+    "missing-observed": 1,
+    "version-mismatch": 2,
+    "host-mismatch": 3,
+    "compat-violation": 4
+  };
   filtered.sort((a, b) => {
     if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    const lead = TYPE_LEADERSHIP[a.type] - TYPE_LEADERSHIP[b.type];
+    if (lead !== 0) return lead;
     if (a.type !== b.type) return a.type.localeCompare(b.type);
     if (a.source !== b.source) return a.source.localeCompare(b.source);
     return a.target.localeCompare(b.target);
   });
-  return import_types19.DivergenceResultSchema.parse({
+  return import_types20.DivergenceResultSchema.parse({
     divergences: filtered,
     totalAffected: filtered.length,
     computedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -4440,23 +4540,23 @@ function canonicalJson(value) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path31.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path31.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path31.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path31.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path31.default.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: import_node_path32.default.join(baseDir, "graph.json"),
+      errorsPath: import_node_path32.default.join(baseDir, "errors.ndjson"),
+      staleEventsPath: import_node_path32.default.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: import_node_path32.default.join(baseDir, "embeddings.json"),
+      policyViolationsPath: import_node_path32.default.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: import_node_path31.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path31.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path31.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path31.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path31.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: import_node_path32.default.join(baseDir, `${project}.json`),
+    errorsPath: import_node_path32.default.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: import_node_path32.default.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: import_node_path32.default.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: import_node_path32.default.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -4494,23 +4594,23 @@ var Projects = class {
 init_cjs_shims();
 var import_node_fs20 = require("fs");
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path32 = __toESM(require("path"), 1);
-var import_types20 = require("@neat.is/types");
+var import_node_path33 = __toESM(require("path"), 1);
+var import_types21 = require("@neat.is/types");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path32.default.resolve(override);
-  return import_node_path32.default.join(import_node_os2.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path33.default.resolve(override);
+  return import_node_path33.default.join(import_node_os2.default.homedir(), ".neat");
 }
 function registryPath() {
-  return import_node_path32.default.join(neatHome(), "projects.json");
+  return import_node_path33.default.join(neatHome(), "projects.json");
 }
 function registryLockPath() {
-  return import_node_path32.default.join(neatHome(), "projects.json.lock");
+  return import_node_path33.default.join(neatHome(), "projects.json.lock");
 }
 async function normalizeProjectPath(input) {
-  const resolved = import_node_path32.default.resolve(input);
+  const resolved = import_node_path33.default.resolve(input);
   try {
     return await import_node_fs20.promises.realpath(resolved);
   } catch {
@@ -4518,7 +4618,7 @@ async function normalizeProjectPath(input) {
   }
 }
 async function writeAtomically(target, contents) {
-  await import_node_fs20.promises.mkdir(import_node_path32.default.dirname(target), { recursive: true });
+  await import_node_fs20.promises.mkdir(import_node_path33.default.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
   const fd = await import_node_fs20.promises.open(tmp, "w");
   try {
@@ -4531,7 +4631,7 @@ async function writeAtomically(target, contents) {
 }
 async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
-  await import_node_fs20.promises.mkdir(import_node_path32.default.dirname(lockPath), { recursive: true });
+  await import_node_fs20.promises.mkdir(import_node_path33.default.dirname(lockPath), { recursive: true });
   while (true) {
     try {
       const fd = await import_node_fs20.promises.open(lockPath, "wx");
@@ -4574,10 +4674,10 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types20.RegistryFileSchema.parse(parsed);
+  return import_types21.RegistryFileSchema.parse(parsed);
 }
 async function writeRegistry(reg) {
-  const validated = import_types20.RegistryFileSchema.parse(reg);
+  const validated = import_types21.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
 var ProjectNameCollisionError = class extends Error {
@@ -4837,11 +4937,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_types21.DivergenceTypeSchema.safeParse(c);
+        const r = import_types22.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types21.DivergenceTypeSchema.options
+            allowed: import_types22.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -5025,7 +5125,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types21.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types22.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -5042,7 +5142,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply);
     if (!proj) return;
-    const parsed = import_types21.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types22.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -5147,14 +5247,14 @@ init_otel_grpc();
 // src/daemon.ts
 init_cjs_shims();
 var import_node_fs21 = require("fs");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_path36 = __toESM(require("path"), 1);
 init_otel();
 function neatHomeFor(opts) {
-  if (opts.neatHome && opts.neatHome.length > 0) return import_node_path35.default.resolve(opts.neatHome);
+  if (opts.neatHome && opts.neatHome.length > 0) return import_node_path36.default.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return import_node_path35.default.resolve(env);
+  if (env && env.length > 0) return import_node_path36.default.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path35.default.join(home, ".neat");
+  return import_node_path36.default.join(home, ".neat");
 }
 function routeSpanToProject(serviceName, projects) {
   if (!serviceName) return DEFAULT_PROJECT;
@@ -5167,7 +5267,7 @@ function routeSpanToProject(serviceName, projects) {
   return DEFAULT_PROJECT;
 }
 async function bootstrapProject(entry) {
-  const paths = pathsForProject(entry.name, import_node_path35.default.join(entry.path, "neat-out"));
+  const paths = pathsForProject(entry.name, import_node_path36.default.join(entry.path, "neat-out"));
   try {
     const stat = await import_node_fs21.promises.stat(entry.path);
     if (!stat.isDirectory()) {
@@ -5240,7 +5340,7 @@ async function startDaemon(opts = {}) {
       `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
     );
   }
-  const pidPath = import_node_path35.default.join(home, "neatd.pid");
+  const pidPath = import_node_path36.default.join(home, "neatd.pid");
   await writeAtomically(pidPath, `${process.pid}
 `);
   const slots = /* @__PURE__ */ new Map();