@neat.is/core 0.4.5 → 0.4.7

package/dist/cli.cjs

@@ -49,9 +49,9 @@ function mountBearerAuth(app, opts) {
   const suffixes = [...DEFAULT_UNAUTH_SUFFIXES, ...opts.extraUnauthenticatedSuffixes ?? []];
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path45 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    const path46 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
     for (const suffix of suffixes) {
-      if (path45 === suffix || path45.endsWith(suffix)) {
+      if (path46 === suffix || path46.endsWith(suffix)) {
         done();
         return;
       }
@@ -562,8 +562,8 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
-var import_node_path44 = __toESM(require("path"), 1);
-var import_node_fs28 = require("fs");
+var import_node_path45 = __toESM(require("path"), 1);
+var import_node_fs29 = require("fs");
 var import_node_url3 = require("url");
 
 // src/graph.ts
@@ -1074,19 +1074,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, path45, edges) {
-    if (path45.length > best.path.length) {
-      best = { path: [...path45], edges: [...edges] };
+  function step(node, path46, edges) {
+    if (path46.length > best.path.length) {
+      best = { path: [...path46], edges: [...edges] };
     }
-    if (path45.length - 1 >= maxDepth) return;
+    if (path46.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);
-      path45.push(srcId);
+      path46.push(srcId);
       edges.push(edge);
-      step(srcId, path45, edges);
-      path45.pop();
+      step(srcId, path46, edges);
+      path46.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -1649,6 +1649,86 @@ function hostFromUrl(u) {
 function pickAddress(span) {
   return pickAttr(span, "server.address", "net.peer.name", "net.host.name") ?? hostFromUrl(pickAttr(span, "url.full", "http.url"));
 }
+var CODE_FILEPATH_ATTR = "code.filepath";
+var CODE_LINENO_ATTR = "code.lineno";
+var CODE_FUNCTION_ATTR = "code.function";
+function toPosix(p) {
+  return p.split("\\").join("/");
+}
+function languageForExt(relPath) {
+  const dot = relPath.lastIndexOf(".");
+  if (dot === -1) return void 0;
+  switch (relPath.slice(dot).toLowerCase()) {
+    case ".py":
+      return "python";
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    default:
+      return void 0;
+  }
+}
+function relPathForRuntimeFile(filepath, serviceNode) {
+  let p = toPosix(filepath).replace(/^file:\/\//, "");
+  const root = serviceNode?.repoPath;
+  if (root && root !== "." && root.length > 0) {
+    const rootPosix = toPosix(root);
+    const anchor = `/${rootPosix}/`;
+    const idx = p.lastIndexOf(anchor);
+    if (idx !== -1) return p.slice(idx + anchor.length);
+    const base = rootPosix.split("/").filter(Boolean).pop();
+    if (base) {
+      const baseAnchor = `/${base}/`;
+      const bidx = p.lastIndexOf(baseAnchor);
+      if (bidx !== -1) return p.slice(bidx + baseAnchor.length);
+    }
+  }
+  p = p.replace(/^[A-Za-z]:/, "").replace(/^\/+/, "");
+  return p.length > 0 ? p : null;
+}
+function callSiteFromSpan(span, serviceNode) {
+  const filepath = span.attributes[CODE_FILEPATH_ATTR];
+  if (typeof filepath !== "string" || filepath.length === 0) return null;
+  const relPath = relPathForRuntimeFile(filepath, serviceNode);
+  if (!relPath) return null;
+  const linenoRaw = span.attributes[CODE_LINENO_ATTR];
+  const line = typeof linenoRaw === "number" && Number.isFinite(linenoRaw) ? linenoRaw : void 0;
+  const fnRaw = span.attributes[CODE_FUNCTION_ATTR];
+  const fn = typeof fnRaw === "string" && fnRaw.length > 0 ? fnRaw : void 0;
+  return { relPath, ...line !== void 0 ? { line } : {}, ...fn ? { fn } : {} };
+}
+function ensureObservedFileNode(graph, serviceName, serviceNodeId, callSite) {
+  const fileNodeId = (0, import_types3.fileId)(serviceName, callSite.relPath);
+  if (!graph.hasNode(fileNodeId)) {
+    const language = languageForExt(callSite.relPath);
+    const node = {
+      id: fileNodeId,
+      type: import_types3.NodeType.FileNode,
+      service: serviceName,
+      path: callSite.relPath,
+      ...language ? { language } : {},
+      discoveredVia: "otel"
+    };
+    graph.addNode(fileNodeId, node);
+  }
+  const containsId = makeObservedEdgeId(import_types3.EdgeType.CONTAINS, serviceNodeId, fileNodeId);
+  if (!graph.hasEdge(containsId)) {
+    const edge = {
+      id: containsId,
+      source: serviceNodeId,
+      target: fileNodeId,
+      type: import_types3.EdgeType.CONTAINS,
+      provenance: import_types3.Provenance.OBSERVED
+    };
+    graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
+  }
+  return fileNodeId;
+}
 function makeObservedEdgeId(type, source, target) {
   return (0, import_types3.observedEdgeId)(source, target, type);
 }
@@ -1891,6 +1971,9 @@ async function handleSpan(ctx, span) {
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = span.statusCode === 2;
   cacheSpanService(span, nowMs);
+  const sourceServiceNode = ctx.graph.getNodeAttributes(sourceId);
+  const callSite = callSiteFromSpan(span, sourceServiceNode);
+  const observedSource = () => callSite ? ensureObservedFileNode(ctx.graph, span.service, sourceId, callSite) : sourceId;
   let affectedNode = sourceId;
   if (span.dbSystem) {
     const host = pickAddress(span);
@@ -1900,7 +1983,7 @@ async function handleSpan(ctx, span) {
       const result = upsertObservedEdge(
         ctx.graph,
         import_types3.EdgeType.CONNECTS_TO,
-        sourceId,
+        observedSource(),
         targetId,
         ts,
         isError
@@ -1916,7 +1999,7 @@ async function handleSpan(ctx, span) {
         upsertObservedEdge(
           ctx.graph,
           import_types3.EdgeType.CALLS,
-          sourceId,
+          observedSource(),
           targetId,
           ts,
           isError
@@ -1928,7 +2011,7 @@ async function handleSpan(ctx, span) {
         upsertObservedEdge(
           ctx.graph,
           import_types3.EdgeType.CALLS,
-          sourceId,
+          observedSource(),
           frontierNodeId,
           ts,
           isError
@@ -3571,7 +3654,7 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/calls/index.ts
 init_cjs_shims();
-var import_types14 = require("@neat.is/types");
+var import_types15 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
@@ -3579,12 +3662,13 @@ var import_node_path20 = __toESM(require("path"), 1);
 var import_tree_sitter = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python = __toESM(require("tree-sitter-python"), 1);
-var import_types9 = require("@neat.is/types");
+var import_types10 = require("@neat.is/types");
 
 // src/extract/calls/shared.ts
 init_cjs_shims();
 var import_node_fs13 = require("fs");
 var import_node_path19 = __toESM(require("path"), 1);
+var import_types9 = require("@neat.is/types");
 async function walkSourceFiles(dir) {
   const out = [];
   async function walk(current) {
@@ -3624,6 +3708,58 @@ function snippet(text, line) {
   const lines = text.split("\n");
   return (lines[line - 1] ?? "").trim();
 }
+function toPosix2(p) {
+  return p.split("\\").join("/");
+}
+function languageForPath(relPath) {
+  switch (import_node_path19.default.extname(relPath).toLowerCase()) {
+    case ".py":
+      return "python";
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    default:
+      return void 0;
+  }
+}
+function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
+  let nodesAdded = 0;
+  let edgesAdded = 0;
+  const fileNodeId = (0, import_types9.fileId)(serviceName, relPath);
+  if (!graph.hasNode(fileNodeId)) {
+    const language = languageForPath(relPath);
+    const node = {
+      id: fileNodeId,
+      type: import_types9.NodeType.FileNode,
+      service: serviceName,
+      path: relPath,
+      ...language ? { language } : {},
+      discoveredVia: "static"
+    };
+    graph.addNode(fileNodeId, node);
+    nodesAdded++;
+  }
+  const containsId = (0, import_types9.extractedEdgeId)(serviceNodeId, fileNodeId, import_types9.EdgeType.CONTAINS);
+  if (!graph.hasEdge(containsId)) {
+    const edge = {
+      id: containsId,
+      source: serviceNodeId,
+      target: fileNodeId,
+      type: import_types9.EdgeType.CONTAINS,
+      provenance: import_types9.Provenance.EXTRACTED,
+      confidence: (0, import_types9.confidenceForExtracted)("structural"),
+      evidence: { file: relPath }
+    };
+    graph.addEdgeWithKey(containsId, serviceNodeId, fileNodeId, edge);
+    edgesAdded++;
+  }
+  return { fileNodeId, nodesAdded, edgesAdded };
+}
 
 // src/extract/calls/http.ts
 var STRING_LITERAL_NODE_TYPES = /* @__PURE__ */ new Set(["string_fragment", "string_content"]);
@@ -3657,16 +3793,16 @@ function callsFromSource(source, parser, knownHosts) {
   const tree = parser.parse(source);
   const literals = [];
   collectStringLiterals(tree.rootNode, literals);
-  const targets = /* @__PURE__ */ new Set();
+  const out = [];
   for (const lit of literals) {
     if (isInsideJsxExternalLink(lit.node)) continue;
     for (const host of knownHosts) {
       if (urlMatchesHost(lit.text, host)) {
-        targets.add(host);
+        out.push({ host, line: lit.node.startPosition.row + 1 });
       }
     }
   }
-  return targets;
+  return out;
 }
 function makeJsParser() {
   const p = new import_tree_sitter.default();
@@ -3689,71 +3825,78 @@ async function addHttpCallEdges(graph, services) {
     hostToNodeId.set(import_node_path20.default.basename(service.dir), service.node.id);
     hostToNodeId.set(service.pkg.name, service.node.id);
   }
+  let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
     const files = await loadSourceFiles(service.dir);
-    const seenTargets = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
       const parser = import_node_path20.default.extname(file.path) === ".py" ? pyParser : jsParser;
-      let targets;
+      let sites;
       try {
-        targets = callsFromSource(file.content, parser, knownHosts);
+        sites = callsFromSource(file.content, parser, knownHosts);
       } catch (err) {
         recordExtractionError("http call extraction", file.path, err);
         continue;
       }
-      for (const t of targets) {
-        const targetId = hostToNodeId.get(t);
+      if (sites.length === 0) continue;
+      const relFile = toPosix2(import_node_path20.default.relative(service.dir, file.path));
+      for (const site of sites) {
+        const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
-        if (!seenTargets.has(targetId)) {
-          seenTargets.set(targetId, { file: file.path, host: t });
+        const dedupKey = `${relFile}|${targetId}`;
+        if (seen.has(dedupKey)) continue;
+        seen.add(dedupKey);
+        const confidence = (0, import_types10.confidenceForExtracted)("hostname-shape-match");
+        const ev = {
+          file: relFile,
+          line: site.line,
+          snippet: snippet(file.content, site.line)
+        };
+        if (!(0, import_types10.passesExtractedFloor)(confidence)) {
+          noteExtractedDropped({
+            source: service.node.id,
+            target: targetId,
+            type: import_types10.EdgeType.CALLS,
+            confidence,
+            confidenceKind: "hostname-shape-match",
+            evidence: ev
+          });
+          continue;
+        }
+        const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
+          graph,
+          service.pkg.name,
+          service.node.id,
+          relFile
+        );
+        nodesAdded += n;
+        edgesAdded += e;
+        const edgeId = (0, import_types4.extractedEdgeId)(fileNodeId, targetId, import_types10.EdgeType.CALLS);
+        if (!graph.hasEdge(edgeId)) {
+          const edge = {
+            id: edgeId,
+            source: fileNodeId,
+            target: targetId,
+            type: import_types10.EdgeType.CALLS,
+            provenance: import_types10.Provenance.EXTRACTED,
+            confidence,
+            evidence: ev
+          };
+          graph.addEdgeWithKey(edgeId, fileNodeId, targetId, edge);
+          edgesAdded++;
         }
-      }
-    }
-    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: edgeId,
-        source: service.node.id,
-        target: targetId,
-        type: import_types9.EdgeType.CALLS,
-        provenance: import_types9.Provenance.EXTRACTED,
-        confidence,
-        evidence: ev
-      };
-      if (!graph.hasEdge(edge.id)) {
-        graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
-        edgesAdded++;
       }
     }
   }
-  return edgesAdded;
+  return { nodesAdded, edgesAdded };
 }
 
 // src/extract/calls/kafka.ts
 init_cjs_shims();
 var import_node_path21 = __toESM(require("path"), 1);
-var import_types10 = require("@neat.is/types");
+var import_types11 = require("@neat.is/types");
 var PRODUCER_TOPIC_RE = /(?:producer|kafkaProducer)[\s\S]{0,40}?\.send\s*\(\s*\{[\s\S]{0,200}?topic\s*:\s*['"`]([^'"`]+)['"`]/g;
 var CONSUMER_TOPIC_RE = /(?:consumer|kafkaConsumer)[\s\S]{0,40}?\.(?:subscribe|run)\s*\(\s*\{[\s\S]{0,200}?topic[s]?\s*:\s*(?:\[\s*)?['"`]([^'"`]+)['"`]/g;
 function findAll(re, text) {
@@ -3774,7 +3917,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, topic);
     out.push({
-      infraId: (0, import_types10.infraId)("kafka-topic", topic),
+      infraId: (0, import_types11.infraId)("kafka-topic", topic),
       name: topic,
       kind: "kafka-topic",
       edgeType,
@@ -3797,7 +3940,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/redis.ts
 init_cjs_shims();
 var import_node_path22 = __toESM(require("path"), 1);
-var import_types11 = require("@neat.is/types");
+var import_types12 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
   const out = [];
@@ -3810,7 +3953,7 @@ function redisEndpointsFromFile(file, serviceDir) {
     seen.add(host);
     const line = lineOf(file.content, host);
     out.push({
-      infraId: (0, import_types11.infraId)("redis", host),
+      infraId: (0, import_types12.infraId)("redis", host),
       name: host,
       kind: "redis",
       edgeType: "CALLS",
@@ -3831,7 +3974,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/aws.ts
 init_cjs_shims();
 var import_node_path23 = __toESM(require("path"), 1);
-var import_types12 = require("@neat.is/types");
+var import_types13 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
 function hasMarker(text, markers) {
@@ -3855,7 +3998,7 @@ function awsEndpointsFromFile(file, serviceDir) {
     seen.add(key);
     const line = lineOf(file.content, name);
     out.push({
-      infraId: (0, import_types12.infraId)(kind, name),
+      infraId: (0, import_types13.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -3890,7 +4033,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/grpc.ts
 init_cjs_shims();
 var import_node_path24 = __toESM(require("path"), 1);
-var import_types13 = require("@neat.is/types");
+var import_types14 = require("@neat.is/types");
 var GRPC_CLIENT_RE = /new\s+([A-Z][A-Za-z0-9_]*)Client\s*\(\s*['"`]?([^,'"`)]+)?/g;
 var AWS_SDK_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@aws-sdk\/client-([a-z0-9-]+)['"`]/g;
 var GRPC_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@grpc\/grpc-js['"`]|_grpc_pb['"`]/;
@@ -3938,7 +4081,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
     const { kind } = classified;
     const line = lineOf(file.content, m[0]);
     out.push({
-      infraId: (0, import_types13.infraId)(kind, name),
+      infraId: (0, import_types14.infraId)(kind, name),
       name,
       kind,
       edgeType: "CALLS",
@@ -3960,11 +4103,11 @@ function grpcEndpointsFromFile(file, serviceDir) {
 function edgeTypeFromEndpoint(ep) {
   switch (ep.edgeType) {
     case "PUBLISHES_TO":
-      return import_types14.EdgeType.PUBLISHES_TO;
+      return import_types15.EdgeType.PUBLISHES_TO;
     case "CONSUMES_FROM":
-      return import_types14.EdgeType.CONSUMES_FROM;
+      return import_types15.EdgeType.CONSUMES_FROM;
     default:
-      return import_types14.EdgeType.CALLS;
+      return import_types15.EdgeType.CALLS;
   }
 }
 function isAwsKind(kind) {
@@ -3991,7 +4134,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: import_types14.NodeType.InfraNode,
+          type: import_types15.NodeType.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -4003,11 +4146,8 @@ async function addExternalEndpointEdges(graph, services) {
         nodesAdded++;
       }
       const edgeType = edgeTypeFromEndpoint(ep);
-      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)) {
+      const confidence = (0, import_types15.confidenceForExtracted)(ep.confidenceKind);
+      if (!(0, import_types15.passesExtractedFloor)(confidence)) {
         noteExtractedDropped({
           source: service.node.id,
           target: ep.infraId,
@@ -4018,13 +4158,25 @@ async function addExternalEndpointEdges(graph, services) {
         });
         continue;
       }
+      const relFile = toPosix2(ep.evidence.file);
+      const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
+        graph,
+        service.pkg.name,
+        service.node.id,
+        relFile
+      );
+      nodesAdded += n;
+      edgesAdded += e;
+      const edgeId = (0, import_types4.extractedEdgeId)(fileNodeId, ep.infraId, edgeType);
+      if (seenEdges.has(edgeId)) continue;
+      seenEdges.add(edgeId);
       if (!graph.hasEdge(edgeId)) {
         const edge = {
           id: edgeId,
-          source: service.node.id,
+          source: fileNodeId,
           target: ep.infraId,
           type: edgeType,
-          provenance: import_types14.Provenance.EXTRACTED,
+          provenance: import_types15.Provenance.EXTRACTED,
           confidence,
           evidence: ep.evidence
         };
@@ -4036,11 +4188,11 @@ async function addExternalEndpointEdges(graph, services) {
   return { nodesAdded, edgesAdded };
 }
 async function addCallEdges(graph, services) {
-  const httpEdges = await addHttpCallEdges(graph, services);
+  const http2 = await addHttpCallEdges(graph, services);
   const ext = await addExternalEndpointEdges(graph, services);
   return {
-    nodesAdded: ext.nodesAdded,
-    edgesAdded: httpEdges + ext.edgesAdded
+    nodesAdded: http2.nodesAdded + ext.nodesAdded,
+    edgesAdded: http2.edgesAdded + ext.edgesAdded
   };
 }
 
@@ -4050,15 +4202,15 @@ init_cjs_shims();
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
 var import_node_path25 = __toESM(require("path"), 1);
-var import_types16 = require("@neat.is/types");
+var import_types17 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
 init_cjs_shims();
-var import_types15 = require("@neat.is/types");
+var import_types16 = require("@neat.is/types");
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
-    id: (0, import_types15.infraId)(kind, name),
-    type: import_types15.NodeType.InfraNode,
+    id: (0, import_types16.infraId)(kind, name),
+    type: import_types16.NodeType.InfraNode,
     name,
     provider,
     kind,
@@ -4137,15 +4289,15 @@ async function addComposeInfra(graph, scanPath, services) {
     for (const dep of dependsOnList(svc.depends_on)) {
       const targetId = composeNameToNodeId.get(dep);
       if (!targetId) continue;
-      const edgeId = (0, import_types4.extractedEdgeId)(sourceId, targetId, import_types16.EdgeType.DEPENDS_ON);
+      const edgeId = (0, import_types4.extractedEdgeId)(sourceId, targetId, import_types17.EdgeType.DEPENDS_ON);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: sourceId,
         target: targetId,
-        type: import_types16.EdgeType.DEPENDS_ON,
-        provenance: import_types16.Provenance.EXTRACTED,
-        confidence: (0, import_types16.confidenceForExtracted)("structural"),
+        type: import_types17.EdgeType.DEPENDS_ON,
+        provenance: import_types17.Provenance.EXTRACTED,
+        confidence: (0, import_types17.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -4159,7 +4311,7 @@ async function addComposeInfra(graph, scanPath, services) {
 init_cjs_shims();
 var import_node_path26 = __toESM(require("path"), 1);
 var import_node_fs14 = require("fs");
-var import_types17 = require("@neat.is/types");
+var import_types18 = require("@neat.is/types");
 function runtimeImage(content) {
   const lines = content.split("\n");
   let last = null;
@@ -4198,15 +4350,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const edgeId = (0, import_types4.extractedEdgeId)(service.node.id, node.id, import_types17.EdgeType.RUNS_ON);
+    const edgeId = (0, import_types4.extractedEdgeId)(service.node.id, node.id, import_types18.EdgeType.RUNS_ON);
     if (!graph.hasEdge(edgeId)) {
       const edge = {
         id: edgeId,
         source: service.node.id,
         target: node.id,
-        type: import_types17.EdgeType.RUNS_ON,
-        provenance: import_types17.Provenance.EXTRACTED,
-        confidence: (0, import_types17.confidenceForExtracted)("structural"),
+        type: import_types18.EdgeType.RUNS_ON,
+        provenance: import_types18.Provenance.EXTRACTED,
+        confidence: (0, import_types18.confidenceForExtracted)("structural"),
         evidence: {
           file: import_node_path26.default.relative(scanPath, dockerfilePath).split(import_node_path26.default.sep).join("/")
         }
@@ -4334,17 +4486,29 @@ var import_node_path30 = __toESM(require("path"), 1);
 init_cjs_shims();
 var import_node_fs17 = require("fs");
 var import_node_path29 = __toESM(require("path"), 1);
-var import_types18 = require("@neat.is/types");
+var import_types19 = require("@neat.is/types");
+function dropOrphanedFileNodes(graph) {
+  const orphans = [];
+  graph.forEachNode((id, attrs) => {
+    if (attrs.type !== import_types19.NodeType.FileNode) return;
+    if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
+      orphans.push(id);
+    }
+  });
+  for (const id of orphans) graph.dropNode(id);
+  return orphans.length;
+}
 function retireEdgesByFile(graph, file) {
   const normalized = file.split("\\").join("/");
   const toDrop = [];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== import_types18.Provenance.EXTRACTED) return;
+    if (edge.provenance !== import_types19.Provenance.EXTRACTED) return;
     if (!edge.evidence?.file) return;
     if (edge.evidence.file === normalized) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
+  dropOrphanedFileNodes(graph);
   return toDrop.length;
 }
 function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
@@ -4352,7 +4516,7 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
   const bases = [scanPath, ...serviceDirs];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== import_types18.Provenance.EXTRACTED) return;
+    if (edge.provenance !== import_types19.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
     if (import_node_path29.default.isAbsolute(evidenceFile)) {
@@ -4363,6 +4527,7 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
+  dropOrphanedFileNodes(graph);
   return toDrop.length;
 }
 
@@ -4430,7 +4595,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
 
 // 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}`;
 }
@@ -4438,22 +4603,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;
       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);
   });
@@ -4462,7 +4627,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;
+  return attrs.type === import_types20.NodeType.FrontierNode;
 }
 function clampConfidence(n) {
   if (!Number.isFinite(n)) return 0;
@@ -4483,6 +4648,7 @@ function gradedConfidence(edge) {
 }
 function detectMissingDivergences(graph, bucket) {
   const out = [];
+  if (bucket.type === import_types20.EdgeType.CONTAINS) return out;
   if (bucket.extracted && !bucket.observed) {
     if (!nodeIsFrontier(graph, bucket.target)) {
       out.push({
@@ -4523,7 +4689,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;
     }
   }
@@ -4536,10 +4702,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;
@@ -4561,10 +4727,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];
@@ -4625,7 +4791,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);
@@ -4658,7 +4824,7 @@ function computeDivergences(graph, opts = {}) {
     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()
@@ -4669,7 +4835,7 @@ function computeDivergences(graph, opts = {}) {
 init_cjs_shims();
 var import_node_fs18 = require("fs");
 var import_node_path31 = __toESM(require("path"), 1);
-var import_types20 = require("@neat.is/types");
+var import_types21 = require("@neat.is/types");
 var SCHEMA_VERSION = 4;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -4691,12 +4857,12 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = import_types20.Provenance.OBSERVED;
+      attrs.provenance = import_types21.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_types20.observedEdgeId)(source, target, type);
+        const newId = (0, import_types21.observedEdgeId)(source, target, type);
         attrs.id = newId;
         if (edge.key) edge.key = newId;
       }
@@ -4816,7 +4982,7 @@ ${NEAT_OUT_LINE}
 
 // src/summary.ts
 init_cjs_shims();
-var import_types21 = require("@neat.is/types");
+var import_types22 = require("@neat.is/types");
 function renderOtelEnvBlock() {
   return [
     "for prod OTel routing, set these in your deploy platform's env:",
@@ -4826,19 +4992,19 @@ function renderOtelEnvBlock() {
 }
 function findIncompatServices(nodes) {
   return nodes.filter(
-    (n) => n.type === import_types21.NodeType.ServiceNode && Array.isArray(n.incompatibilities) && (n.incompatibilities ?? []).length > 0
+    (n) => n.type === import_types22.NodeType.ServiceNode && Array.isArray(n.incompatibilities) && (n.incompatibilities ?? []).length > 0
   );
 }
 function servicesWithoutObserved(nodes, edges) {
   const seen = /* @__PURE__ */ new Set();
   for (const e of edges) {
-    if (e.provenance === import_types21.Provenance.OBSERVED) {
+    if (e.provenance === import_types22.Provenance.OBSERVED) {
       seen.add(e.source);
       seen.add(e.target);
     }
   }
   return nodes.filter(
-    (n) => n.type === import_types21.NodeType.ServiceNode && !seen.has(n.id)
+    (n) => n.type === import_types22.NodeType.ServiceNode && !seen.has(n.id)
   );
 }
 function formatDivergence(d) {
@@ -4920,7 +5086,7 @@ var import_chokidar = __toESM(require("chokidar"), 1);
 init_cjs_shims();
 var import_fastify = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types23 = require("@neat.is/types");
+var import_types24 = require("@neat.is/types");
 
 // src/diff.ts
 init_cjs_shims();
@@ -5056,7 +5222,7 @@ init_cjs_shims();
 var import_node_fs21 = require("fs");
 var import_node_os2 = __toESM(require("os"), 1);
 var import_node_path34 = __toESM(require("path"), 1);
-var import_types22 = require("@neat.is/types");
+var import_types23 = require("@neat.is/types");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
@@ -5135,10 +5301,10 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types22.RegistryFileSchema.parse(parsed);
+  return import_types23.RegistryFileSchema.parse(parsed);
 }
 async function writeRegistry(reg) {
-  const validated = import_types22.RegistryFileSchema.parse(reg);
+  const validated = import_types23.RegistryFileSchema.parse(reg);
   await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
 }
 var ProjectNameCollisionError = class extends Error {
@@ -5401,11 +5567,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_types23.DivergenceTypeSchema.safeParse(c);
+        const r = import_types24.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types23.DivergenceTypeSchema.options
+            allowed: import_types24.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -5618,7 +5784,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types23.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types24.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -5635,7 +5801,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap);
     if (!proj) return;
-    const parsed = import_types23.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types24.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -6569,38 +6735,119 @@ var import_node_path40 = __toESM(require("path"), 1);
 // src/installers/templates.ts
 init_cjs_shims();
 var OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-069). OpenTelemetry auto-instrumentation hook.";
+var OTEL_INIT_STAMP = "// neat-template-version: 2 \u2014 file-first call-site capture (ADR-089).";
+function neatCallsiteProcessorSource(ts) {
+  const stackT = ts ? ": string" : "";
+  const spanT = ts ? ": any" : "";
+  const strOpt = ts ? ": string | undefined" : "";
+  return `function __neatPickUserFrame(stack${stackT}) {
+  const lines = String(stack || '').split('\\n')
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].trim()
+    if (raw.indexOf('at ') !== 0) continue
+    if (raw.indexOf('node_modules') !== -1) continue
+    if (raw.indexOf('@opentelemetry') !== -1) continue
+    if (raw.indexOf('node:') !== -1) continue
+    if (raw.indexOf('NeatCallSiteSpanProcessor') !== -1) continue
+    const bodyText = raw.slice(3)
+    const loc = bodyText.match(/:(\\d+):(\\d+)\\)?$/)
+    if (!loc) continue
+    const paren = bodyText.lastIndexOf('(')
+    let filepath${strOpt}
+    let fn${strOpt}
+    if (paren !== -1) {
+      fn = bodyText.slice(0, paren).trim()
+      if (fn.indexOf('async ') === 0) fn = fn.slice(6)
+      if (fn.indexOf('new ') === 0) fn = fn.slice(4)
+      filepath = bodyText.slice(paren + 1, bodyText.length - loc[0].length)
+    } else {
+      filepath = bodyText.slice(0, bodyText.length - loc[0].length)
+    }
+    if (filepath.indexOf('file://') === 0) filepath = filepath.slice(7)
+    if (!filepath) continue
+    return { filepath: filepath, lineno: Number(loc[1]), function: fn || undefined }
+  }
+  return null
+}
+
+class NeatCallSiteSpanProcessor {
+  onStart(span${spanT}) {
+    if (!span || (span.kind !== 2 && span.kind !== 3)) return
+    const frame = __neatPickUserFrame(new Error().stack)
+    if (!frame) return
+    span.setAttribute('code.filepath', frame.filepath)
+    if (typeof frame.lineno === 'number') span.setAttribute('code.lineno', frame.lineno)
+    if (frame.function) span.setAttribute('code.function', frame.function)
+  }
+  onEnd() {}
+  forceFlush() { return Promise.resolve() }
+  shutdown() { return Promise.resolve() }
+}`;
+}
+var CALLSITE_PROCESSOR_JS = neatCallsiteProcessorSource(false);
+var CALLSITE_PROCESSOR_TS = neatCallsiteProcessorSource(true);
+function neatRegisterCallsiteSource(ts) {
+  const providerT = ts ? ": any" : "";
+  return `try {
+  const provider${providerT} = trace.getTracerProvider()
+  const delegate = provider && typeof provider.getDelegate === 'function' ? provider.getDelegate() : provider
+  if (delegate && typeof delegate.addSpanProcessor === 'function') {
+    delegate.addSpanProcessor(new NeatCallSiteSpanProcessor())
+  }
+} catch {
+  // capture is best-effort; span export is unaffected
+}`;
+}
 var OTEL_INIT_CJS = `${OTEL_INIT_HEADER}
+${OTEL_INIT_STAMP}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
 process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 const { NodeSDK } = require('@opentelemetry/sdk-node')
 const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
+const { trace } = require('@opentelemetry/api')
+
+${CALLSITE_PROCESSOR_JS}
 
 const instrumentations = [getNodeAutoInstrumentations()]
 __INSTRUMENTATION_BLOCK__
-new NodeSDK({ instrumentations }).start()
+const sdk = new NodeSDK({ instrumentations })
+sdk.start()
+${neatRegisterCallsiteSource(false)}
 `;
 var OTEL_INIT_ESM = `${OTEL_INIT_HEADER}
+${OTEL_INIT_STAMP}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
 process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 import { NodeSDK } from '@opentelemetry/sdk-node'
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
+import { trace } from '@opentelemetry/api'
+
+${CALLSITE_PROCESSOR_JS}
 
 const instrumentations = [getNodeAutoInstrumentations()]
 __INSTRUMENTATION_BLOCK__
-new NodeSDK({ instrumentations }).start()
+const sdk = new NodeSDK({ instrumentations })
+sdk.start()
+${neatRegisterCallsiteSource(false)}
 `;
 var OTEL_INIT_TS = `${OTEL_INIT_HEADER}
+${OTEL_INIT_STAMP}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
 process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
 
 import { NodeSDK } from '@opentelemetry/sdk-node'
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
+import { trace } from '@opentelemetry/api'
+
+${CALLSITE_PROCESSOR_TS}
 
 const instrumentations = [getNodeAutoInstrumentations()]
 __INSTRUMENTATION_BLOCK__
-new NodeSDK({ instrumentations }).start()
+const sdk = new NodeSDK({ instrumentations })
+sdk.start()
+${neatRegisterCallsiteSource(true)}
 `;
 function renderNodeOtelInit(template, serviceName, projectName, registrations = []) {
   const block = registrations.length === 0 ? "" : `
@@ -6753,13 +7000,20 @@ var SDK_PACKAGES = [
   { name: "@opentelemetry/sdk-node", version: "^0.57.0" },
   { name: "@opentelemetry/auto-instrumentations-node", version: "^0.55.0" }
 ];
+function getMajor(versionRange) {
+  if (!versionRange) return 0;
+  const match = versionRange.match(/(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
+}
 function detectNonBundledInstrumentations(pkg) {
   const deps = allDeps(pkg);
   const out = [];
   if ("@prisma/client" in deps) {
+    const prismaMajor = getMajor(deps["@prisma/client"]);
+    const prismaInstrVersion = prismaMajor >= 6 ? "^6.0.0" : "^5.0.0";
     out.push({
       pkg: "@prisma/instrumentation",
-      version: "^5.0.0",
+      version: prismaInstrVersion,
       registration: "instrumentations.push(new (require('@prisma/instrumentation').PrismaInstrumentation)())"
     });
   }
@@ -6817,6 +7071,23 @@ async function exists2(p) {
     return false;
   }
 }
+async function readFileMaybe(p) {
+  try {
+    return await import_node_fs25.promises.readFile(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function planOtelInitGeneration(file, contents) {
+  const existing = await readFileMaybe(file);
+  if (existing === null) {
+    return { file, contents, skipIfExists: true };
+  }
+  if (existing.includes(OTEL_INIT_HEADER) && !existing.includes(OTEL_INIT_STAMP)) {
+    return { file, contents, skipIfExists: false };
+  }
+  return null;
+}
 async function detect(serviceDir) {
   const pkg = await readPackageJson(serviceDir);
   return pkg !== null && typeof pkg.name === "string";
@@ -7547,18 +7818,11 @@ async function plan(serviceDir, opts) {
   const projectName = projectToken(pkg, serviceDir, project);
   const registrations = nonBundled.map((i) => i.registration);
   const generatedFiles = [];
-  if (!await exists2(otelInitFile)) {
-    generatedFiles.push({
-      file: otelInitFile,
-      contents: renderNodeOtelInit(
-        otelInitContents(flavor),
-        svcName,
-        projectName,
-        registrations
-      ),
-      skipIfExists: true
-    });
-  }
+  const otelInitGen = await planOtelInitGeneration(
+    otelInitFile,
+    renderNodeOtelInit(otelInitContents(flavor), svcName, projectName, registrations)
+  );
+  if (otelInitGen) generatedFiles.push(otelInitGen);
   if (!await exists2(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
@@ -8088,19 +8352,100 @@ function renderPatch(sections) {
 
 // src/orchestrator.ts
 init_cjs_shims();
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_net = __toESM(require("net"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+var import_node_readline = __toESM(require("readline"), 1);
+
+// src/installers/package-manager.ts
+init_cjs_shims();
+var import_node_fs27 = require("fs");
 var import_node_path42 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
-var import_node_readline = __toESM(require("readline"), 1);
+var LOCKFILE_PRIORITY = [
+  { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
+  { lockfile: "pnpm-lock.yaml", pm: "pnpm", args: ["install", "--no-summary"] },
+  { lockfile: "yarn.lock", pm: "yarn", args: ["install", "--silent"] },
+  {
+    lockfile: "package-lock.json",
+    pm: "npm",
+    args: ["install", "--no-audit", "--no-fund", "--prefer-offline"]
+  }
+];
+var NPM_FALLBACK_ARGS = ["install", "--no-audit", "--no-fund", "--prefer-offline"];
+async function exists4(p) {
+  try {
+    await import_node_fs27.promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(serviceDir) {
+  let dir = import_node_path42.default.resolve(serviceDir);
+  const stops = /* @__PURE__ */ new Set();
+  for (let i = 0; i < 64; i++) {
+    if (stops.has(dir)) break;
+    stops.add(dir);
+    for (const candidate of LOCKFILE_PRIORITY) {
+      const lockPath = import_node_path42.default.join(dir, candidate.lockfile);
+      if (await exists4(lockPath)) {
+        return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
+      }
+    }
+    const parent = import_node_path42.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { pm: "npm", cwd: import_node_path42.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+}
+async function runPackageManagerInstall(cmd) {
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process2.spawn)(cmd.pm, cmd.args, {
+      cwd: cmd.cwd,
+      // Inherit PATH + HOME so the user's installed managers resolve.
+      env: process.env,
+      // `false` keeps the parent in control of cleanup if the orchestrator
+      // exits before install finishes. Cross-platform-safe.
+      shell: false,
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolve({
+        pm: cmd.pm,
+        cwd: cmd.cwd,
+        args: cmd.args,
+        exitCode: 127,
+        stderr: stderr + `
+${err.message}`
+      });
+    });
+    child.on("close", (code) => {
+      resolve({
+        pm: cmd.pm,
+        cwd: cmd.cwd,
+        args: cmd.args,
+        exitCode: code ?? 1,
+        stderr: stderr.trim()
+      });
+    });
+  });
+}
+
+// src/orchestrator.ts
 async function extractAndPersist(opts) {
   const services = await discoverServices(opts.scanPath);
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
   const graphKey = opts.projectExplicit ? opts.project : DEFAULT_PROJECT;
   resetGraph(graphKey);
   const graph = getGraph(graphKey);
-  const projectPaths = pathsForProject(graphKey, import_node_path42.default.join(opts.scanPath, "neat-out"));
+  const projectPaths = pathsForProject(graphKey, import_node_path43.default.join(opts.scanPath, "neat-out"));
   const extraction = await extractFromDirectory(graph, opts.scanPath, {
     errorsPath: projectPaths.errorsPath
   });
@@ -8118,12 +8463,15 @@ async function extractAndPersist(opts) {
     errorsPath: projectPaths.errorsPath
   };
 }
-async function applyInstallersOver(services, project) {
+async function applyInstallersOver(services, project, options = {}) {
+  const resolveManager = options.resolveManager ?? detectPackageManager;
+  const runInstall = options.runInstall ?? runPackageManagerInstall;
   let instrumented = 0;
   let already = 0;
   let libOnly = 0;
   let browserBundle = 0;
   let reactNative = 0;
+  const installPlans = /* @__PURE__ */ new Map();
   for (const svc of services) {
     const installer = await pickInstaller(svc.dir);
     if (!installer) continue;
@@ -8133,8 +8481,14 @@ async function applyInstallersOver(services, project) {
       continue;
     }
     const outcome = await installer.apply(plan3);
-    if (outcome.outcome === "instrumented") instrumented++;
-    else if (outcome.outcome === "already-instrumented") already++;
+    if (outcome.outcome === "instrumented") {
+      instrumented++;
+      if (plan3.dependencyEdits.length > 0) {
+        const cmd = await resolveManager(svc.dir);
+        const key = `${cmd.pm}:${cmd.cwd}`;
+        if (!installPlans.has(key)) installPlans.set(key, cmd);
+      }
+    } else if (outcome.outcome === "already-instrumented") already++;
     else if (outcome.outcome === "lib-only") libOnly++;
     else if (outcome.outcome === "browser-bundle") {
       browserBundle++;
@@ -8144,7 +8498,30 @@ async function applyInstallersOver(services, project) {
       console.log(`skipping ${svc.dir}: React Native target; browser-OTel support lands in a future release.`);
     }
   }
-  return { instrumented, alreadyInstrumented: already, libOnly, browserBundle, reactNative };
+  const packageManagerInstalls = [];
+  for (const cmd of installPlans.values()) {
+    console.log(`running \`${cmd.pm} ${cmd.args.join(" ")}\` in ${cmd.cwd}`);
+    const result = await runInstall(cmd);
+    packageManagerInstalls.push(result);
+    if (result.exitCode !== 0) {
+      console.error(
+        `neat: ${cmd.pm} install failed in ${cmd.cwd} (exit ${result.exitCode}); run it manually to surface the error.`
+      );
+      if (result.stderr.length > 0) {
+        for (const line of result.stderr.split(/\r?\n/).slice(0, 20)) {
+          console.error(`  ${line}`);
+        }
+      }
+    }
+  }
+  return {
+    instrumented,
+    alreadyInstrumented: already,
+    libOnly,
+    browserBundle,
+    reactNative,
+    packageManagerInstalls
+  };
 }
 async function promptYesNo(question) {
   const rl = import_node_readline.default.createInterface({ input: process.stdin, output: process.stdout });
@@ -8280,10 +8657,10 @@ function formatPortCollisionMessage(port) {
   ];
 }
 function spawnDaemonDetached() {
-  const here = import_node_path42.default.dirname(new URL(importMetaUrl).pathname);
+  const here = import_node_path43.default.dirname(new URL(importMetaUrl).pathname);
   const candidates = [
-    import_node_path42.default.join(here, "neatd.cjs"),
-    import_node_path42.default.join(here, "neatd.js")
+    import_node_path43.default.join(here, "neatd.cjs"),
+    import_node_path43.default.join(here, "neatd.js")
   ];
   let entry2 = null;
   const fsSync = require("fs");
@@ -8303,7 +8680,7 @@ function spawnDaemonDetached() {
   if (!hasToken && (!env.HOST || env.HOST.length === 0)) {
     env.HOST = "127.0.0.1";
   }
-  const child = (0, import_node_child_process2.spawn)(process.execPath, [entry2, "start"], {
+  const child = (0, import_node_child_process3.spawn)(process.execPath, [entry2, "start"], {
     detached: true,
     // stderr inherits the orchestrator's fd so the daemon's
     // `BindAuthorityError` message lands in front of the operator instead
@@ -8320,7 +8697,7 @@ function openBrowser(url) {
   const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
   const args = platform === "win32" ? ["/c", "start", "", url] : [url];
   try {
-    const child = (0, import_node_child_process2.spawn)(cmd, args, { detached: true, stdio: "ignore" });
+    const child = (0, import_node_child_process3.spawn)(cmd, args, { detached: true, stdio: "ignore" });
     child.on("error", () => {
     });
     child.unref();
@@ -8341,7 +8718,7 @@ async function runOrchestrator(opts) {
       browser: "skipped"
     }
   };
-  const stat = await import_node_fs27.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs28.promises.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat: ${opts.scanPath} is not a directory`);
     result.exitCode = 2;
@@ -8409,6 +8786,10 @@ async function runOrchestrator(opts) {
     console.log(
       `instrumented ${tally.instrumented}, already ${tally.alreadyInstrumented}, lib-only ${tally.libOnly}`
     );
+    const failedInstalls = tally.packageManagerInstalls.filter((i) => i.exitCode !== 0);
+    if (failedInstalls.length > 0) {
+      result.exitCode = 1;
+    }
   }
   const restPort = Number(process.env.PORT ?? 8080);
   const timeoutMs = opts.daemonReadyTimeoutMs ?? DEFAULT_DAEMON_READY_TIMEOUT_MS;
@@ -8480,11 +8861,11 @@ function printSummary(result, graph, dashboardUrl) {
 
 // src/cli-verbs.ts
 init_cjs_shims();
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 
 // src/cli-client.ts
 init_cjs_shims();
-var import_types24 = require("@neat.is/types");
+var import_types25 = require("@neat.is/types");
 var HttpError = class extends Error {
   constructor(status2, message, responseBody = "") {
     super(message);
@@ -8505,10 +8886,10 @@ function createHttpClient(baseUrl, bearerToken) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path45) {
+    async get(path46) {
       let res;
       try {
-        res = await fetch(`${root}${path45}`, {
+        res = await fetch(`${root}${path46}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -8520,16 +8901,16 @@ function createHttpClient(baseUrl, bearerToken) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path45}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path46}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path45, body) {
+    async post(path46, body) {
       let res;
       try {
-        res = await fetch(`${root}${path45}`, {
+        res = await fetch(`${root}${path46}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -8543,7 +8924,7 @@ function createHttpClient(baseUrl, bearerToken) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path45}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path46}: ${text}`,
           text
         );
       }
@@ -8557,12 +8938,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path45 = projectPath(
+  const path46 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path45);
+    const result = await client.get(path46);
     const arrowPath = result.traversalPath.join(" \u2190 ");
     const provenances = result.edgeProvenances.length ? result.edgeProvenances.join(", ") : "(direct, no edges traversed)";
     const summary = `Root cause for ${input.errorNode} is ${result.rootCauseNode}. ` + result.rootCauseReason + (result.fixRecommendation ? ` Recommended fix: ${result.fixRecommendation}.` : "");
@@ -8588,12 +8969,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path45 = projectPath(
+  const path46 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path45);
+    const result = await client.get(path46);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no downstream dependencies. Nothing else would break if it failed.`
@@ -8622,17 +9003,17 @@ async function runBlastRadius(client, input) {
   }
 }
 function formatBlastEntry(n) {
-  const tag = n.edgeProvenance === import_types24.Provenance.STALE ? " [STALE \u2014 last seen too long ago]" : "";
+  const tag = n.edgeProvenance === import_types25.Provenance.STALE ? " [STALE \u2014 last seen too long ago]" : "";
   return `  \u2022 ${n.nodeId} (distance ${n.distance}, ${n.edgeProvenance})${tag}`;
 }
 async function runDependencies(client, input) {
   const depth = input.depth ?? 3;
-  const path45 = projectPath(
+  const path46 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path45);
+    const result = await client.get(path46);
     if (result.total === 0) {
       return {
         summary: depth === 1 ? `${input.nodeId} has no direct dependencies in the graph.` : `${input.nodeId} has no dependencies (BFS to depth ${depth}).`
@@ -8668,9 +9049,9 @@ async function runObservedDependencies(client, input) {
     const edges = await client.get(
       projectPath(input.project, `/graph/edges/${encodeURIComponent(input.nodeId)}`)
     );
-    const observed = edges.outbound.filter((e) => e.provenance === import_types24.Provenance.OBSERVED);
+    const observed = edges.outbound.filter((e) => e.provenance === import_types25.Provenance.OBSERVED);
     if (observed.length === 0) {
-      const hasExtracted = edges.outbound.some((e) => e.provenance === import_types24.Provenance.EXTRACTED);
+      const hasExtracted = edges.outbound.some((e) => e.provenance === import_types25.Provenance.EXTRACTED);
       const note = hasExtracted ? " Static (EXTRACTED) dependencies exist but no runtime traffic has been seen \u2014 is OTel running?" : "";
       return { summary: `No OBSERVED dependencies for ${input.nodeId}.${note}` };
     }
@@ -8678,7 +9059,7 @@ async function runObservedDependencies(client, input) {
     return {
       summary: `${input.nodeId} has ${observed.length} runtime dependenc${observed.length === 1 ? "y" : "ies"} confirmed by OTel.`,
       block: blockLines.join("\n"),
-      provenance: import_types24.Provenance.OBSERVED
+      provenance: import_types25.Provenance.OBSERVED
     };
   } catch (err) {
     if (err instanceof HttpError && err.status === 404) {
@@ -8713,9 +9094,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path45 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
+  const path46 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
   try {
-    const body = await client.get(path45);
+    const body = await client.get(path46);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -8732,7 +9113,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_types24.Provenance.OBSERVED
+      provenance: import_types25.Provenance.OBSERVED
     };
   } catch (err) {
     if (err instanceof HttpError && err.status === 404) {
@@ -8841,7 +9222,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_types24.Provenance.STALE
+    provenance: import_types25.Provenance.STALE
   };
 }
 async function runPolicies(client, input) {
@@ -9005,7 +9386,7 @@ async function resolveProjectEntry(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const resolvedCwd = await normalizeProjectPath(cwd);
   for (const entry2 of entries) {
-    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${import_node_path43.default.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${import_node_path44.default.sep}`)) {
       return entry2;
     }
   }
@@ -9155,7 +9536,7 @@ async function runSync(opts) {
 }
 
 // src/cli.ts
-var import_types25 = require("@neat.is/types");
+var import_types26 = require("@neat.is/types");
 function usage() {
   console.log("usage: neat <command> [args] [--project <name>]");
   console.log("");
@@ -9365,14 +9746,14 @@ function assignFlag(out, field, value) {
   out[field] = value;
 }
 function readPackageVersion() {
-  const here = typeof __dirname !== "undefined" ? __dirname : import_node_path44.default.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
+  const here = typeof __dirname !== "undefined" ? __dirname : import_node_path45.default.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
   const candidates = [
-    import_node_path44.default.resolve(here, "../package.json"),
-    import_node_path44.default.resolve(here, "../../package.json")
+    import_node_path45.default.resolve(here, "../package.json"),
+    import_node_path45.default.resolve(here, "../../package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const raw = (0, import_node_fs28.readFileSync)(candidate, "utf8");
+      const raw = (0, import_node_fs29.readFileSync)(candidate, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.name === "@neat.is/core" && typeof parsed.version === "string") {
         return parsed.version;
@@ -9436,7 +9817,7 @@ async function buildPatchSections(services, project) {
 }
 async function runInit(opts) {
   const written = [];
-  const stat = await import_node_fs28.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs29.promises.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat init: ${opts.scanPath} is not a directory`);
     return { exitCode: 2, writtenFiles: written };
@@ -9445,13 +9826,13 @@ async function runInit(opts) {
   printDiscoveryReport(opts, services);
   const sections = opts.noInstall ? [] : await buildPatchSections(services, opts.project);
   const patch = renderPatch(sections);
-  const patchPath = import_node_path44.default.join(opts.scanPath, "neat.patch");
+  const patchPath = import_node_path45.default.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
-    await import_node_fs28.promises.writeFile(patchPath, patch, "utf8");
+    await import_node_fs29.promises.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = import_node_path44.default.join(opts.scanPath, ".gitignore");
-    const gitignoreExists = await import_node_fs28.promises.stat(gitignorePath).then(() => true).catch(() => false);
+    const gitignorePath = import_node_path45.default.join(opts.scanPath, ".gitignore");
+    const gitignoreExists = await import_node_fs29.promises.stat(gitignorePath).then(() => true).catch(() => false);
     const verb = gitignoreExists ? "append" : "create";
     console.log(`dry-run: would ${verb} ${gitignorePath} (add neat-out/)`);
     console.log("rerun without --dry-run to register and snapshot.");
@@ -9462,9 +9843,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    import_node_path44.default.join(opts.scanPath, "neat-out")
+    import_node_path45.default.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = import_node_path44.default.join(import_node_path44.default.dirname(opts.outPath), import_node_path44.default.basename(projectPaths.errorsPath));
+  const errorsPath = import_node_path45.default.join(import_node_path45.default.dirname(opts.outPath), import_node_path45.default.basename(projectPaths.errorsPath));
   const result = await extractFromDirectory(graph, opts.scanPath, { errorsPath });
   await saveGraphToDisk(graph, opts.outPath);
   written.push(opts.outPath);
@@ -9543,7 +9924,7 @@ async function runInit(opts) {
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
-      await import_node_fs28.promises.writeFile(patchPath, patch, "utf8");
+      await import_node_fs29.promises.writeFile(patchPath, patch, "utf8");
       written.push(patchPath);
     }
   }
@@ -9583,9 +9964,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return import_node_path44.default.resolve(override);
+  if (override && override.length > 0) return import_node_path45.default.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path44.default.join(home, ".claude.json");
+  return import_node_path45.default.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet2 = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -9597,7 +9978,7 @@ async function runSkill(opts) {
     const target = claudeConfigPath();
     let existing = {};
     try {
-      existing = JSON.parse(await import_node_fs28.promises.readFile(target, "utf8"));
+      existing = JSON.parse(await import_node_fs29.promises.readFile(target, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
@@ -9609,8 +9990,8 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await import_node_fs28.promises.mkdir(import_node_path44.default.dirname(target), { recursive: true });
-    await import_node_fs28.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    await import_node_fs29.promises.mkdir(import_node_path45.default.dirname(target), { recursive: true });
+    await import_node_fs29.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
     console.log(`neat skill: wrote mcpServers.neat to ${target}`);
     console.log("restart Claude Code to pick up the new MCP server.");
     return { exitCode: 0 };
@@ -9648,12 +10029,12 @@ async function main() {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = import_node_path44.default.resolve(target);
+    const scanPath = import_node_path45.default.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : import_node_path44.default.basename(scanPath);
+    const projectName = projectExplicit ? project : import_node_path45.default.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, import_node_path44.default.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = import_node_path44.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const fallback = pathsForProject(projectKey, import_node_path45.default.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = import_node_path45.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
     const result = await runInit({
       scanPath,
       outPath,
@@ -9674,21 +10055,21 @@ async function main() {
       usage();
       process.exit(2);
     }
-    const scanPath = import_node_path44.default.resolve(target);
-    const stat = await import_node_fs28.promises.stat(scanPath).catch(() => null);
+    const scanPath = import_node_path45.default.resolve(target);
+    const stat = await import_node_fs29.promises.stat(scanPath).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       console.error(`neat watch: ${scanPath} is not a directory`);
       process.exit(2);
     }
-    const projectPaths = pathsForProject(project, import_node_path44.default.join(scanPath, "neat-out"));
-    const outPath = import_node_path44.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = import_node_path44.default.resolve(
-      process.env.NEAT_ERRORS_PATH ?? import_node_path44.default.join(import_node_path44.default.dirname(outPath), import_node_path44.default.basename(projectPaths.errorsPath))
+    const projectPaths = pathsForProject(project, import_node_path45.default.join(scanPath, "neat-out"));
+    const outPath = import_node_path45.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = import_node_path45.default.resolve(
+      process.env.NEAT_ERRORS_PATH ?? import_node_path45.default.join(import_node_path45.default.dirname(outPath), import_node_path45.default.basename(projectPaths.errorsPath))
     );
-    const staleEventsPath = import_node_path44.default.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path44.default.join(import_node_path44.default.dirname(outPath), import_node_path44.default.basename(projectPaths.staleEventsPath))
+    const staleEventsPath = import_node_path45.default.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path45.default.join(import_node_path45.default.dirname(outPath), import_node_path45.default.basename(projectPaths.staleEventsPath))
     );
-    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path44.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path45.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
     const handle = await startWatch(getGraph(project), {
       scanPath,
       outPath,
@@ -9834,11 +10215,11 @@ async function main() {
   process.exit(1);
 }
 async function tryOrchestrator(cmd, parsed) {
-  const scanPath = import_node_path44.default.resolve(cmd);
-  const stat = await import_node_fs28.promises.stat(scanPath).catch(() => null);
+  const scanPath = import_node_path45.default.resolve(cmd);
+  const stat = await import_node_fs29.promises.stat(scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) return null;
   const projectExplicit = parsed.project !== null;
-  const projectName = projectExplicit ? parsed.project : import_node_path44.default.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : import_node_path45.default.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,
@@ -9988,10 +10369,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_types25.DivergenceTypeSchema.safeParse(p);
+          const r = import_types26.DivergenceTypeSchema.safeParse(p);
           if (!r.success) {
             console.error(
-              `neat divergences: unknown --type "${p}". allowed: ${import_types25.DivergenceTypeSchema.options.join(", ")}`
+              `neat divergences: unknown --type "${p}". allowed: ${import_types26.DivergenceTypeSchema.options.join(", ")}`
             );
             return 2;
           }