@neat.is/core 0.7.9 → 0.7.10

package/dist/cli.cjs

@@ -61,8 +61,8 @@ function mountBearerAuth(app, opts) {
   ]);
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path82 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
-    if (exactUnauthPaths.has(path82) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path82)) {
+    const path84 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    if (exactUnauthPaths.has(path84) || PROJECT_SCOPED_UNAUTH_PATTERN.test(path84)) {
       done();
       return;
     }
@@ -415,8 +415,8 @@ function websocketChannelPathOf(attrs) {
     const v = attrs[key];
     if (typeof v === "string" && v.length > 0) {
       const q = v.indexOf("?");
-      const path82 = q === -1 ? v : v.slice(0, q);
-      if (path82.length > 0) return path82;
+      const path84 = q === -1 ? v : v.slice(0, q);
+      if (path84.length > 0) return path84;
     }
   }
   return void 0;
@@ -771,9 +771,9 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
-var import_node_path81 = __toESM(require("path"), 1);
+var import_node_path83 = __toESM(require("path"), 1);
 var import_node_os8 = __toESM(require("os"), 1);
-var import_node_fs46 = require("fs");
+var import_node_fs48 = require("fs");
 
 // src/banner.ts
 init_cjs_shims();
@@ -1341,19 +1341,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, path82, edges) {
-    if (path82.length > best.path.length) {
-      best = { path: [...path82], edges: [...edges] };
+  function step(node, path84, edges) {
+    if (path84.length > best.path.length) {
+      best = { path: [...path84], edges: [...edges] };
     }
-    if (path82.length - 1 >= maxDepth) return;
+    if (path84.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);
-      path82.push(srcId);
+      path84.push(srcId);
       edges.push(edge);
-      step(srcId, path82, edges);
-      path82.pop();
+      step(srcId, path84, edges);
+      path84.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -1560,26 +1560,26 @@ function dominantFailingCall(graph, serviceId9, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path82 = [originServiceId];
+  const path84 = [originServiceId];
   const edges = [];
   const visited = /* @__PURE__ */ new Set([originServiceId]);
   let current = originServiceId;
   for (let depth = 0; depth < maxDepth; depth++) {
     const hop = dominantFailingCall(graph, current, visited);
     if (!hop) break;
-    path82.push(hop.nextService);
+    path84.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path82, edges, culprit: current };
+  return { path: path84, edges, culprit: current };
 }
 function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   const chain = followFailingCallChain(graph, originId, ROOT_CAUSE_MAX_DEPTH);
   if (!chain) return null;
   const culprit = chain.culprit;
-  const path82 = [...chain.path];
+  const path84 = [...chain.path];
   const edgeProvenances = chain.edges.map((e) => e.provenance);
   const baseConfidence = confidenceFromMix(chain.edges);
   const confidence = Math.max(0, Math.min(1, baseConfidence * INCIDENT_ROOT_CAUSE_CONFIDENCE));
@@ -1587,14 +1587,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path82.push(loc.fileNode);
+      path84.push(loc.fileNode);
       edgeProvenances.push(import_types.Provenance.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return import_types.RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path82,
+      traversalPath: path84,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -1606,7 +1606,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   return import_types.RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
-    traversalPath: path82,
+    traversalPath: path84,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -2274,6 +2274,7 @@ var import_yaml = require("yaml");
 var import_types3 = require("@neat.is/types");
 var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py", ".go", ".rb", ".php"]);
 var CONFIG_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var JSON_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["app.json", "app.config.json", "eas.json"]);
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -2313,6 +2314,7 @@ async function isPythonVenvDir(dir) {
 function isConfigFile(name) {
   const ext = import_node_path4.default.extname(name);
   if (CONFIG_FILE_EXTENSIONS.has(ext)) return { match: true, fileType: ext.slice(1) };
+  if (JSON_CONFIG_FILENAMES.has(name)) return { match: true, fileType: "json" };
   if (name === ".env" || name.startsWith(".env.")) {
     if (isEnvTemplateFile(name)) return { match: false, fileType: "" };
     if (isNeatAuthoredEnvFile(name)) return { match: false, fileType: "" };
@@ -3141,8 +3143,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path82) {
-  return path82.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path84) {
+  return path84.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -3814,9 +3816,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path82 = rubyLiteral(k);
-    if (path82 === null) continue;
-    return { path: path82, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path84 = rubyLiteral(k);
+    if (path84 === null) continue;
+    return { path: path84, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -4436,7 +4438,7 @@ async function expressMountPrefixes(files, serviceDir, tsPaths) {
   };
   const filePrefix = /* @__PURE__ */ new Map();
   const conflicted = /* @__PURE__ */ new Set();
-  const apply4 = (file, prefix) => {
+  const apply6 = (file, prefix) => {
     if (conflicted.has(file)) return;
     const existing = filePrefix.get(file);
     if (existing === void 0) filePrefix.set(file, prefix);
@@ -4453,7 +4455,7 @@ async function expressMountPrefixes(files, serviceDir, tsPaths) {
     const info = fileInfo.get(file);
     const rv = info?.routerVars.get(name);
     if (!info || !rv) return;
-    if (rv.declares && info.appVars.size === 0) apply4(file, accPrefix);
+    if (rv.declares && info.appVars.size === 0) apply6(file, accPrefix);
     for (const m of rv.mounts) {
       if (!m.target) continue;
       const t = resolveTarget(m.target, file);
@@ -5429,6 +5431,21 @@ async function appendErrorEvent(ctx, ev) {
   await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(ctx.errorsPath), { recursive: true });
   await import_node_fs8.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
+async function appendConnectorIncident(errorsPath, input) {
+  const ev = {
+    id: input.id,
+    timestamp: input.timestamp,
+    service: input.service,
+    traceId: input.id,
+    spanId: input.id,
+    errorType: input.errorType,
+    errorMessage: input.errorMessage,
+    ...input.attributes && Object.keys(input.attributes).length > 0 ? { attributes: input.attributes } : {},
+    affectedNode: input.affectedNode
+  };
+  await import_node_fs8.promises.mkdir(import_node_path9.default.dirname(errorsPath), { recursive: true });
+  await import_node_fs8.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+}
 function incidentAffectedNode(span, graph, scanPath) {
   const sid = graph ? resolveFusedServiceId(graph, span.service, span.env) : (0, import_types8.serviceId)(span.service, span.env);
   const serviceNode = graph && graph.hasNode(sid) ? graph.getNodeAttributes(sid) : void 0;
@@ -11242,8 +11259,41 @@ var import_tree_sitter14 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_go3 = __toESM(require("tree-sitter-go"), 1);
 var import_types35 = require("@neat.is/types");
 init_otel();
-var SQL_METHODS = /* @__PURE__ */ new Set(["Exec", "ExecContext", "Query", "QueryContext", "QueryRow", "QueryRowContext"]);
 var PARSE_CHUNK10 = 16384;
+var DATABASE_SQL_METHODS = /* @__PURE__ */ new Set([
+  "Query",
+  "QueryContext",
+  "QueryRow",
+  "QueryRowContext",
+  "Exec",
+  "ExecContext",
+  "Prepare",
+  "PrepareContext"
+]);
+var SQLX_METHODS = /* @__PURE__ */ new Set([
+  "Get",
+  "Select",
+  "Queryx",
+  "QueryRowx",
+  "NamedExec",
+  "NamedQuery",
+  "MustExec",
+  "Preparex",
+  "GetContext",
+  "SelectContext"
+]);
+var DATABASE_SQL_IMPORT = "database/sql";
+var SQLX_IMPORT = "github.com/jmoiron/sqlx";
+function makeGoParser3() {
+  const p = new import_tree_sitter14.default();
+  p.setLanguage(import_tree_sitter_go3.default);
+  return p;
+}
+function parseSource10(parser, source) {
+  return parser.parse(
+    (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK10)
+  );
+}
 function walk7(node, visit) {
   visit(node);
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -11251,25 +11301,54 @@ function walk7(node, visit) {
     if (child) walk7(child, visit);
   }
 }
+function goStringLiteralValue(node) {
+  if (!node) return null;
+  if (node.type === "interpreted_string_literal" || node.type === "raw_string_literal") {
+    const t = node.text;
+    return t.length >= 2 ? t.slice(1, -1) : "";
+  }
+  return null;
+}
+function goImportsAny(root, names) {
+  let found = false;
+  walk7(root, (node) => {
+    if (found || node.type !== "import_spec") return;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const value = goStringLiteralValue(node.namedChild(i));
+      if (value !== null && names.has(value)) found = true;
+    }
+  });
+  return found;
+}
+function firstStringLiteralArg(argsNode) {
+  if (!argsNode) return null;
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const value = goStringLiteralValue(argsNode.namedChild(i));
+    if (value !== null) return value;
+  }
+  return null;
+}
 function goSqlEndpointsFromFile(file, serviceDir) {
   if (import_node_path48.default.extname(file.path) !== ".go") return [];
-  const parser = new import_tree_sitter14.default();
-  parser.setLanguage(import_tree_sitter_go3.default);
-  const tree = parser.parse(
-    (index) => index >= file.content.length ? "" : file.content.slice(index, index + PARSE_CHUNK10)
-  );
+  if (!file.content.includes(DATABASE_SQL_IMPORT) && !file.content.includes(SQLX_IMPORT)) return [];
+  const tree = parseSource10(makeGoParser3(), file.content);
+  const importsDatabaseSql = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([DATABASE_SQL_IMPORT]));
+  const importsSqlx = goImportsAny(tree.rootNode, /* @__PURE__ */ new Set([SQLX_IMPORT]));
+  if (!importsDatabaseSql && !importsSqlx) return [];
   const out = [];
   walk7(tree.rootNode, (node) => {
     if (node.type !== "call_expression") return;
     const fn = node.childForFieldName("function");
     if (fn?.type !== "selector_expression") return;
     const method = fn.childForFieldName("field")?.text;
-    if (!method || !SQL_METHODS.has(method)) return;
-    const arg = node.childForFieldName("arguments")?.namedChild(0);
-    if (!arg || arg.type !== "interpreted_string_literal" && arg.type !== "raw_string_literal") return;
-    const sql = arg.text.slice(1, -1);
+    if (!method) return;
+    const recognized = DATABASE_SQL_METHODS.has(method) || importsSqlx && SQLX_METHODS.has(method);
+    if (!recognized) return;
+    const sql = firstStringLiteralArg(node.childForFieldName("arguments"));
+    if (sql === null) return;
     const table = tableFromSqlStatement(sql);
     if (!table) return;
+    const columns = columnsFromSqlStatement(sql);
     const line = node.startPosition.row + 1;
     out.push({
       infraId: (0, import_types35.infraId)("sql-table", table),
@@ -11277,7 +11356,12 @@ function goSqlEndpointsFromFile(file, serviceDir) {
       kind: "sql-table",
       edgeType: "CALLS",
       confidenceKind: "verified-call-site",
-      evidence: { file: toPosix(import_node_path48.default.relative(serviceDir, file.path)), line, snippet: snippet(file.content, line) }
+      ...columns.length > 0 ? { columns } : {},
+      evidence: {
+        file: toPosix(import_node_path48.default.relative(serviceDir, file.path)),
+        line,
+        snippet: snippet(file.content, line)
+      }
     });
   });
   return out;
@@ -11291,12 +11375,12 @@ var import_tree_sitter_go4 = __toESM(require("tree-sitter-go"), 1);
 var import_types36 = require("@neat.is/types");
 var GORM_IMPORT_RE = /gorm\.io\/gorm/;
 var PARSE_CHUNK11 = 16384;
-function makeGoParser3() {
+function makeGoParser4() {
   const p = new import_tree_sitter15.default();
   p.setLanguage(import_tree_sitter_go4.default);
   return p;
 }
-function parseSource10(parser, source) {
+function parseSource11(parser, source) {
   return parser.parse(
     (index) => index >= source.length ? "" : source.slice(index, index + PARSE_CHUNK11)
   );
@@ -11720,7 +11804,7 @@ function collectColumns(struct, structs, seen, prefix, out, emitted) {
 function gormEndpointsFromFile(file, serviceDir) {
   if (import_node_path49.default.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource10(makeGoParser3(), file.content);
+  const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
   const out = [];
   const seenTables = /* @__PURE__ */ new Set();
@@ -11751,7 +11835,7 @@ function gormEndpointsFromFile(file, serviceDir) {
 function gormForeignKeys(file, serviceDir) {
   if (import_node_path49.default.extname(file.path) !== ".go") return [];
   if (!GORM_IMPORT_RE.test(file.content)) return [];
-  const tree = parseSource10(makeGoParser3(), file.content);
+  const tree = parseSource11(makeGoParser4(), file.content);
   const { structs, models, tableFor } = analyze(tree);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -13978,7 +14062,7 @@ var import_chokidar = __toESM(require("chokidar"), 1);
 init_cjs_shims();
 var import_fastify2 = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types81 = require("@neat.is/types");
+var import_types86 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -15307,6 +15391,23 @@ async function runConnectorPoll(connector, ctx, graph, resolveTarget) {
       unresolved++;
       continue;
     }
+    if (signal.incident) {
+      ensureServiceNode(graph, resolved.serviceName, NO_ENV);
+      if (!ctx.errorsPath || !graph.hasNode(resolved.targetNodeId)) {
+        unresolved++;
+        continue;
+      }
+      await appendConnectorIncident(ctx.errorsPath, {
+        id: signal.incident.id,
+        timestamp: signal.incident.timestamp,
+        service: signal.incident.service,
+        errorType: signal.incident.errorType,
+        errorMessage: signal.incident.errorMessage,
+        ...signal.incident.attributes ? { attributes: signal.incident.attributes } : {},
+        affectedNode: resolved.targetNodeId
+      });
+      continue;
+    }
     if (resolved.ensureInfraNode) {
       const { kind, name, provider } = resolved.ensureInfraNode;
       ensureInfraNode(graph, kind, name, provider);
@@ -15772,10 +15873,10 @@ var SUPABASE_RPC_TARGET_KIND = "supabase-rpc";
 // src/connectors/supabase/map.ts
 var REST_RPC_PATH_RE = /^\/rest\/v1\/rpc\/([^/?]+)/;
 var REST_TABLE_PATH_RE = /^\/rest\/v1\/([^/?]+)/;
-function targetFromRestPath(path82) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path82);
+function targetFromRestPath(path84) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path84);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path82);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path84);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -16379,9 +16480,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path82 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path82) return null;
-  return { resourceName, method, path: path82 };
+  const path84 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path84) return null;
+  return { resourceName, method, path: path84 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -16419,14 +16520,14 @@ function mapLogEntryToSignal(entry2) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path82 = pathFromRequestUrl(req.requestUrl);
-  if (path82 === null) return null;
+  const path84 = pathFromRequestUrl(req.requestUrl);
+  if (path84 === null) return null;
   const timestamp = entry2.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD2;
   return {
     targetKind: resourceType,
-    targetName: packFirebaseTargetName({ resourceName, method, path: path82 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path84 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -16633,7 +16734,7 @@ function mapEventToSignal(event) {
   if (Number.isNaN(observedAt.getTime())) return null;
   const statusCode = metadata?.statusCode;
   const isError = typeof statusCode === "number" && statusCode >= ERROR_STATUS_THRESHOLD3;
-  const path82 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path84 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -16641,7 +16742,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path82 ? { path: path82 } : {},
+    ...path84 ? { path: path84 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -16687,8 +16788,8 @@ function findTaggedWorkerFileNode(graph, workerName) {
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path82) {
-  const normalizedPath = normalizePathTemplate(path82);
+function findMatchingRouteNode(graph, serviceName, method, path84) {
+  const normalizedPath = normalizePathTemplate(path84);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
@@ -16705,10 +16806,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path82 } = signal;
+    const { method, path: path84 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path82) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path82) ?? wholeFileId;
+      if (!method || !path84) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path84) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -17060,9 +17161,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path82 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path82) return null;
-  return { serviceName, method, path: path82 };
+  const path84 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path84) return null;
+  return { serviceName, method, path: path84 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -17091,14 +17192,14 @@ function mapLogEntryToSignal2(entry2) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path82 = pathFromRequestUrl2(req.requestUrl);
-  if (path82 === null) return null;
+  const path84 = pathFromRequestUrl2(req.requestUrl);
+  if (path84 === null) return null;
   const timestamp = entry2.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD4;
   return {
     targetKind: CLOUD_RUN_TARGET_KIND,
-    targetName: packCloudRunTargetName({ serviceName, method, path: path82 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path84 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -17137,14 +17238,14 @@ function createCloudRunResolveTarget(graph, config) {
     if (signal.targetKind !== CLOUD_RUN_TARGET_KIND) return null;
     const identity = parseCloudRunTargetName(signal.targetName);
     if (!identity) return null;
-    const { serviceName: gcpServiceName, method, path: path82 } = identity;
+    const { serviceName: gcpServiceName, method, path: path84 } = identity;
     const mappedService = config.serviceMap?.[gcpServiceName];
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path82)
+        normalizePathTemplate(path84)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: import_types71.EdgeType.CALLS };
@@ -17541,6 +17642,338 @@ function createPlanetscaleConnector(graph, config, deps = {}) {
   };
 }
 
+// src/connectors/eas/index.ts
+init_cjs_shims();
+
+// src/connectors/eas/client.ts
+init_cjs_shims();
+
+// src/connectors/eas/types.ts
+init_cjs_shims();
+function readEasCredentials(raw) {
+  const token = raw["token"];
+  if (typeof token !== "string" || token.length === 0) {
+    throw new Error("eas connector: credentials.token (EXPO_TOKEN) must be a non-empty string");
+  }
+  return { token };
+}
+var EAS_STATUS_ERRORED = "ERRORED";
+var TRANSIENT_BUILD_PHASES = /* @__PURE__ */ new Set([
+  "SPIN_UP_BUILDER",
+  "PREPARE_CREDENTIALS",
+  "RESTORE_CACHE",
+  "UPLOAD_APPLICATION_ARCHIVE"
+]);
+var INTERNAL_ERROR_CODE = /INTERNAL_SERVER_ERROR|EAS_BUILD_.*INTERNAL|_INTERNAL_ERROR|UNKNOWN_ERROR/i;
+function isTransientFailure(err) {
+  if (!err) return false;
+  const phase = typeof err.buildPhase === "string" ? err.buildPhase : void 0;
+  if (phase) {
+    if (TRANSIENT_BUILD_PHASES.has(phase)) return true;
+    if (/^SPIN_UP|_CREDENTIALS$|^RESTORE_CACHE/i.test(phase)) return true;
+  }
+  const code = typeof err.errorCode === "string" ? err.errorCode : void 0;
+  if (code && INTERNAL_ERROR_CODE.test(code)) return true;
+  return false;
+}
+var FIELD_SEP3 = "\0";
+var EAS_TARGET_KIND = "eas-build";
+function packEasTargetName(identity) {
+  return [identity.serviceName, identity.phase].join(FIELD_SEP3);
+}
+function parseEasTargetName(targetName) {
+  const sep = targetName.indexOf(FIELD_SEP3);
+  if (sep === -1) return null;
+  const serviceName = targetName.slice(0, sep);
+  const phase = targetName.slice(sep + 1);
+  if (!serviceName) return null;
+  return { serviceName, phase };
+}
+
+// src/connectors/eas/client.ts
+var DEFAULT_EAS_API_URL = "https://api.expo.dev/graphql";
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_MAX_PAGES = 10;
+var DEFAULT_MAX_LOG_BYTES = 16 * 1024;
+var DEFAULT_MAX_LOOKBACK_MS6 = 7 * 24 * 60 * 60 * 1e3;
+var BUILDS_QUERY = `
+  query NeatEasErroredBuilds($appId: String!, $offset: Int!, $limit: Int!) {
+    app {
+      byId(appId: $appId) {
+        builds(offset: $offset, limit: $limit, filter: { status: ERRORED }) {
+          id
+          status
+          platform
+          buildProfile
+          gitCommitHash
+          gitCommitMessage
+          gitRef
+          isGitWorkingTreeDirty
+          createdAt
+          completedAt
+          error {
+            buildPhase
+            errorCode
+            message
+            docsUrl
+          }
+          logFileUrls
+        }
+      }
+    }
+  }
+`;
+async function easGraphQL(apiUrl, token, query, variables, accountKey, fetchImpl) {
+  const res = await junctionFetch(
+    apiUrl,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...bearerAuthHeader(token)
+      },
+      body: JSON.stringify({ query, variables })
+    },
+    // accountKey: the Expo app id — the per-(provider, accountKey) rate-limit
+    // bucket (ADR-131), the closest thing this connector carries to "one account".
+    { provider: "eas", accountKey, ...fetchImpl ? { fetchImpl } : {} }
+  );
+  if (!res.ok) {
+    throw new Error(`Expo GraphQL request failed: ${res.status} ${res.statusText}`);
+  }
+  const body = await res.json();
+  if (body.errors && body.errors.length > 0) {
+    throw new Error(`Expo GraphQL errors: ${body.errors.map((e) => e.message).join("; ")}`);
+  }
+  if (!body.data) throw new Error("Expo GraphQL response carried no data");
+  return body.data;
+}
+async function fetchErroredBuilds(token, config, fetchImpl) {
+  const apiUrl = config.apiUrl ?? DEFAULT_EAS_API_URL;
+  const pageSize = config.pageSize ?? DEFAULT_PAGE_SIZE;
+  const maxPages = config.maxPages ?? DEFAULT_MAX_PAGES;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let page = 0; page < maxPages; page++) {
+    const data = await easGraphQL(
+      apiUrl,
+      token,
+      BUILDS_QUERY,
+      { appId: config.appId, offset: page * pageSize, limit: pageSize },
+      config.appId,
+      fetchImpl
+    );
+    const builds = data.app?.byId?.builds;
+    if (!Array.isArray(builds)) break;
+    let added = 0;
+    for (const b of builds) {
+      if (!b || typeof b.id !== "string" || b.id.length === 0) continue;
+      if (b.status !== EAS_STATUS_ERRORED) continue;
+      if (seen.has(b.id)) continue;
+      seen.add(b.id);
+      out.push(b);
+      added++;
+    }
+    if (builds.length < pageSize) break;
+    if (added === 0) break;
+  }
+  return out;
+}
+async function fetchBuildLogs(logFileUrls, maxBytes = DEFAULT_MAX_LOG_BYTES, fetchImpl) {
+  if (!Array.isArray(logFileUrls) || logFileUrls.length === 0) return "";
+  const doFetch = fetchImpl ?? fetch;
+  const chunks = [];
+  for (const url of logFileUrls) {
+    if (typeof url !== "string" || url.length === 0) continue;
+    try {
+      const res = await doFetch(url);
+      if (!res.ok) continue;
+      chunks.push(await res.text());
+    } catch {
+    }
+  }
+  const joined = chunks.join("\n");
+  return joined.length > maxBytes ? joined.slice(joined.length - maxBytes) : joined;
+}
+
+// src/connectors/eas/map.ts
+init_cjs_shims();
+function buildEventTime(build) {
+  if (typeof build.completedAt === "string" && build.completedAt.length > 0) return build.completedAt;
+  if (typeof build.createdAt === "string" && build.createdAt.length > 0) return build.createdAt;
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function incidentMessage2(build) {
+  const err = build.error ?? {};
+  const phase = typeof err.buildPhase === "string" && err.buildPhase.length > 0 ? ` at ${err.buildPhase}` : "";
+  const detail = typeof err.message === "string" && err.message.trim().length > 0 && err.message.trim() || typeof err.errorCode === "string" && err.errorCode.length > 0 && err.errorCode || "no error detail reported";
+  let msg = `EAS build failed${phase}: ${detail}`;
+  if (build.isGitWorkingTreeDirty === true) {
+    msg += " (built from a dirty working tree \u2014 the commit may not represent what built)";
+  }
+  return msg;
+}
+function incidentAttributes(build) {
+  const attrs = {};
+  const err = build.error ?? {};
+  const put = (k, v) => {
+    if (typeof v === "string" && v.length === 0) return;
+    if (v !== void 0 && v !== null) attrs[k] = v;
+  };
+  put("eas.buildId", build.id);
+  put("eas.platform", build.platform ?? void 0);
+  put("eas.buildProfile", build.buildProfile ?? void 0);
+  put("eas.buildPhase", err.buildPhase ?? void 0);
+  put("eas.errorCode", err.errorCode ?? void 0);
+  put("eas.docsUrl", err.docsUrl ?? void 0);
+  put("eas.gitCommitHash", build.gitCommitHash ?? void 0);
+  put("eas.gitRef", build.gitRef ?? void 0);
+  put("eas.gitCommitMessage", build.gitCommitMessage ?? void 0);
+  if (typeof build.isGitWorkingTreeDirty === "boolean") {
+    attrs["eas.gitWorkingTreeDirty"] = build.isGitWorkingTreeDirty;
+    if (build.isGitWorkingTreeDirty) attrs["eas.confidence"] = "low";
+  }
+  put("eas.createdAt", build.createdAt ?? void 0);
+  put("eas.completedAt", build.completedAt ?? void 0);
+  if (typeof build.logsText === "string" && build.logsText.length > 0) {
+    attrs["eas.logs"] = build.logsText;
+  }
+  return attrs;
+}
+function mapBuildToSignal(build, serviceName) {
+  if (!build || typeof build !== "object") return null;
+  if (build.status !== EAS_STATUS_ERRORED) return null;
+  if (!build.error) return null;
+  if (isTransientFailure(build.error)) return null;
+  const timestamp = buildEventTime(build);
+  const phase = typeof build.error.buildPhase === "string" ? build.error.buildPhase : "";
+  return {
+    targetKind: EAS_TARGET_KIND,
+    targetName: packEasTargetName({ serviceName, phase }),
+    // Incident-only — no edge, so no call/error count to replay.
+    callCount: 0,
+    errorCount: 0,
+    lastObservedIso: timestamp,
+    incident: {
+      id: `eas:build:${build.id}`,
+      timestamp,
+      service: serviceName,
+      errorType: "eas-build-failure",
+      errorMessage: incidentMessage2(build),
+      attributes: incidentAttributes(build)
+    }
+  };
+}
+function mapBuildsToSignals(builds, serviceName) {
+  const out = [];
+  for (const build of builds) {
+    const signal = mapBuildToSignal(build, serviceName);
+    if (signal) out.push(signal);
+  }
+  return out;
+}
+
+// src/connectors/eas/resolve.ts
+init_cjs_shims();
+var import_types83 = require("@neat.is/types");
+var NO_ENV2 = "unknown";
+var EAS_JSON_PHASES = /* @__PURE__ */ new Set(["READ_EAS_JSON"]);
+var APP_CONFIG_PHASES = /* @__PURE__ */ new Set([
+  "READ_APP_CONFIG",
+  "CONFIGURE_EXPO_UPDATES",
+  "CALCULATE_EXPO_UPDATES_RUNTIME_VERSION"
+]);
+function configBasenamesForPhase(phase) {
+  if (EAS_JSON_PHASES.has(phase)) return ["eas.json"];
+  if (APP_CONFIG_PHASES.has(phase)) return ["app.json", "app.config.json"];
+  return [];
+}
+function configNodeService(graph, configNodeId) {
+  for (const edgeId of graph.inboundEdges(configNodeId)) {
+    const edge = graph.getEdgeAttributes(edgeId);
+    if (edge.type !== import_types83.EdgeType.CONFIGURED_BY) continue;
+    const parsed = (0, import_types83.parseFileId)(edge.source);
+    if (parsed) return parsed.service;
+  }
+  return null;
+}
+function findConfigNode(graph, basenames, serviceName) {
+  let scoped = null;
+  let anyMatch = null;
+  graph.forEachNode((id, attrs) => {
+    if (scoped) return;
+    const node = attrs;
+    if (node.type !== import_types83.NodeType.ConfigNode) return;
+    if (typeof node.name !== "string" || !basenames.includes(node.name)) return;
+    if (anyMatch === null) anyMatch = id;
+    if (configNodeService(graph, id) === serviceName) scoped = id;
+  });
+  return scoped ?? anyMatch;
+}
+function createEasResolveTarget(graph) {
+  return (signal) => {
+    if (signal.targetKind !== EAS_TARGET_KIND) return null;
+    const identity = parseEasTargetName(signal.targetName);
+    if (!identity) return null;
+    const { serviceName, phase } = identity;
+    const basenames = configBasenamesForPhase(phase);
+    if (basenames.length > 0) {
+      const configNodeId = findConfigNode(graph, basenames, serviceName);
+      if (configNodeId) {
+        return { targetNodeId: configNodeId, serviceName, edgeType: import_types83.EdgeType.CALLS };
+      }
+    }
+    return {
+      targetNodeId: resolveFusedServiceId(graph, serviceName, NO_ENV2),
+      serviceName,
+      edgeType: import_types83.EdgeType.CALLS
+    };
+  };
+}
+
+// src/connectors/eas/index.ts
+function isBuildSince(build, sinceIso) {
+  const t = Date.parse(buildEventTime(build));
+  const s = Date.parse(sinceIso);
+  if (Number.isNaN(t) || Number.isNaN(s)) return true;
+  return t > s;
+}
+function boundedSinceIso2(since, now, maxLookbackMs) {
+  const floor = new Date(now.getTime() - maxLookbackMs);
+  if (!since) return floor.toISOString();
+  const sinceMs = new Date(since).getTime();
+  if (Number.isNaN(sinceMs)) return floor.toISOString();
+  return sinceMs < floor.getTime() ? floor.toISOString() : new Date(sinceMs).toISOString();
+}
+var EasConnector = class {
+  constructor(config, fetchImpl) {
+    this.config = config;
+    this.fetchImpl = fetchImpl;
+  }
+  config;
+  fetchImpl;
+  provider = "eas";
+  async poll(ctx) {
+    const creds = readEasCredentials(ctx.credentials);
+    const serviceName = this.config.serviceName ?? this.config.appId;
+    const maxLookbackMs = this.config.maxLookbackMs ?? DEFAULT_MAX_LOOKBACK_MS6;
+    const sinceIso = boundedSinceIso2(ctx.since, /* @__PURE__ */ new Date(), maxLookbackMs);
+    const builds = await fetchErroredBuilds(creds.token, this.config, this.fetchImpl);
+    const fresh = builds.filter((b) => isBuildSince(b, sinceIso));
+    const maxLogBytes = this.config.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES;
+    for (const build of fresh) {
+      build.logsText = await fetchBuildLogs(build.logFileUrls, maxLogBytes, this.fetchImpl);
+    }
+    return mapBuildsToSignals(fresh, serviceName);
+  }
+};
+function createEasConnector(graph, config, fetchImpl) {
+  return {
+    connector: new EasConnector(config, fetchImpl),
+    resolveTarget: createEasResolveTarget(graph)
+  };
+}
+
 // src/connectors/registry.ts
 var CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4";
 async function authProbe(input) {
@@ -17828,6 +18261,41 @@ var PROVIDER_DISPATCH = {
         ...fetchImpl ? { fetchImpl } : {}
       });
     }
+  },
+  eas: {
+    provider: "eas",
+    // The secret is a single robot-user EXPO_TOKEN; a single-string credential
+    // maps to `token`. `appId` is non-secret config (connector-config.md §7.1).
+    primaryCredentialKey: "token",
+    requiredCredentialFields: ["token"],
+    requiredOptionFields: ["appId"],
+    build(graph, options) {
+      return createEasConnector(graph, options);
+    },
+    // Runs the connector's real `builds` query at limit 1 — the exact read poll()
+    // performs, minus the pages — so the probe checks both that the EXPO_TOKEN
+    // authenticates and that this app id is reachable, the same probe-the-real-
+    // query discipline Railway and Cloud Run use over a trivial `{ __typename }`.
+    // A bad or wrong-scoped token comes back as an Expo GraphQL error, which
+    // `fetchErroredBuilds` throws on, so it fails honestly here rather than
+    // silently at the first poll.
+    async validate({ credentials, options, fetchImpl }) {
+      const cfg = options;
+      const appId = String(cfg.appId ?? "");
+      if (!appId) return { ok: false, reason: "eas: appId is required to validate" };
+      const probeConfig = {
+        appId,
+        pageSize: 1,
+        maxPages: 1,
+        ...cfg.apiUrl ? { apiUrl: cfg.apiUrl } : {}
+      };
+      try {
+        await fetchErroredBuilds(String(credentials.token ?? ""), probeConfig, fetchImpl);
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, reason: `eas auth check failed: ${err.message}` };
+      }
+    }
   }
 };
 function vercelCredsFrom(credentials) {
@@ -18040,7 +18508,11 @@ async function startConnectorPolling(input) {
   const stopFns = all.map(
     (registration) => startConnectorPollLoop(
       registration.connector,
-      { projectDir: input.projectDir, credentials: registration.credentials },
+      {
+        projectDir: input.projectDir,
+        credentials: registration.credentials,
+        ...input.errorsPath ? { errorsPath: input.errorsPath } : {}
+      },
       input.graph,
       registration.resolveTarget,
       { intervalMs: registration.intervalMs, connectorId: registration.id }
@@ -18258,11 +18730,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_types81.DivergenceTypeSchema.safeParse(c);
+        const r = import_types86.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types81.DivergenceTypeSchema.options
+            allowed: import_types86.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -18369,10 +18841,15 @@ function registerRoutes(scope, ctx) {
       }
       const reg = built.registration;
       const at = (/* @__PURE__ */ new Date()).toISOString();
+      const incidentsPath = errorsPathFor(proj);
       try {
         const result = await ctx.runPoll(
           reg.connector,
-          { projectDir: proj.scanPath ?? "", credentials: reg.credentials },
+          {
+            projectDir: proj.scanPath ?? "",
+            credentials: reg.credentials,
+            ...incidentsPath ? { errorsPath: incidentsPath } : {}
+          },
           proj.graph,
           reg.resolveTarget
         );
@@ -18571,7 +19048,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types81.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types86.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -18610,7 +19087,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
-    const parsed = import_types81.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types86.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -18943,7 +19420,7 @@ var import_node_fs34 = require("fs");
 var import_node_path68 = __toESM(require("path"), 1);
 
 // src/daemon.ts
-var import_types82 = require("@neat.is/types");
+var import_types87 = require("@neat.is/types");
 function daemonJsonPath(scanPath) {
   return import_node_path69.default.join(scanPath, "neat-out", "daemon.json");
 }
@@ -19601,6 +20078,9 @@ async function startWatch(graph, opts) {
     project: projectName,
     graph,
     projectDir: opts.scanPath,
+    // Incident ledger for an incident-emitting connector (ADR-185), same path
+    // `neat watch`'s own error-span writer already uses.
+    errorsPath: opts.errorsPath,
     ...opts.neatHome ? { home: opts.neatHome } : {},
     onSkip: (skipped, reason) => console.warn(
       `neat watch: connector "${skipped.id}" (${skipped.provider}) skipped for project "${projectName}" \u2014 ${reason}`
@@ -22229,14 +22709,519 @@ async function apply3(installPlan) {
     await import_node_fs41.promises.writeFile(generated.file, generated.contents, "utf8");
     writtenFiles.push(generated.file);
   }
-  return { serviceDir: installPlan.serviceDir, outcome: writtenFiles.length ? "instrumented" : "already-instrumented", writtenFiles };
+  const wroteManifest = writtenFiles.some((f) => f.split(/[\\/]/).pop() === "go.mod");
+  return {
+    serviceDir: installPlan.serviceDir,
+    outcome: writtenFiles.length ? "instrumented" : "already-instrumented",
+    writtenFiles,
+    ...wroteManifest ? { followUpInstall: "go mod download" } : {}
+  };
 }
 var goInstaller = { name: "go", detect: detect3, plan: plan3, apply: apply3 };
 
+// src/installers/ruby.ts
+init_cjs_shims();
+var import_node_fs42 = require("fs");
+var import_node_path76 = __toESM(require("path"), 1);
+var RUBY_MARKERS = [
+  "Gemfile",
+  "Gemfile.lock"
+];
+var RUBY_GEMS = [
+  { name: "opentelemetry-sdk", version: "~> 1.5" },
+  { name: "opentelemetry-exporter-otlp", version: "~> 0.29" },
+  { name: "opentelemetry-instrumentation-all", version: "~> 0.62" }
+];
+var NEAT_OTEL_STAMP2 = "neat-otel-init v1";
+var INITIALIZER_REL = import_node_path76.default.join("config", "initializers", "neat_otel.rb");
+function neatOtelRb(opts = {}) {
+  const service = opts.project ?? "ruby-service";
+  const endpoint2 = opts.project ? `http://localhost:4318/projects/${opts.project}/v1/traces` : "http://localhost:4318/v1/traces";
+  return `# ${NEAT_OTEL_STAMP2} \u2014 generated by NEAT. Safe to re-generate; do not edit.
+# Rails auto-loads this at boot (config/initializers/*). It points the
+# OpenTelemetry SDK at your NEAT daemon, enables the Ruby auto-instrumentation
+# set, and installs a span processor that stamps code.file.path /
+# code.line.number / code.function.name on the CLIENT/PRODUCER spans your app
+# issues, so NEAT fuses each runtime span onto the source file that made the
+# call (docs/contracts/file-awareness.md). Absolute paths are emitted here;
+# ingest anchors them against the service root. If the OpenTelemetry gems are
+# not installed this file degrades to a no-op rather than breaking boot.
+
+begin
+  require 'opentelemetry/sdk'
+  require 'opentelemetry/exporter/otlp'
+  require 'opentelemetry/instrumentation/all'
+  _neat_otel_loaded = true
+rescue LoadError
+  _neat_otel_loaded = false
+end
+
+if _neat_otel_loaded && ENV['NEAT_CALLSITE_DISABLED'] != '1'
+  # Walk the Ruby call stack to the first application frame and stamp the stable
+  # OTel source attributes on CLIENT/PRODUCER spans. SERVER spans are created
+  # before the handler runs, so they stay route/service-grained, honestly.
+  class NeatCallSiteSpanProcessor
+    def initialize(root)
+      @root = root.to_s.end_with?(File::SEPARATOR) ? root.to_s : root.to_s + File::SEPARATOR
+    end
+
+    def on_start(span, _parent_context)
+      kind = span.kind
+      return unless kind == OpenTelemetry::Trace::SpanKind::CLIENT ||
+                    kind == OpenTelemetry::Trace::SpanKind::PRODUCER
+      caller_locations(1).each do |loc|
+        file = loc.absolute_path || loc.path
+        next if file.nil?
+        next unless file.start_with?(@root)
+        next if file.include?('/vendor/') || file.include?('/.bundle/')
+        next if file.end_with?('neat_otel.rb')
+        span.set_attribute('code.file.path', file)
+        span.set_attribute('code.line.number', loc.lineno)
+        span.set_attribute('code.function.name', loc.label.to_s)
+        break
+      end
+    rescue StandardError
+      # never break the host application
+    end
+
+    def on_finish(_span); end
+
+    def force_flush(timeout: nil)
+      OpenTelemetry::SDK::Trace::Export::SUCCESS
+    end
+
+    def shutdown(timeout: nil)
+      OpenTelemetry::SDK::Trace::Export::SUCCESS
+    end
+  end
+
+  _neat_root = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+  _neat_service = ENV.fetch('OTEL_SERVICE_NAME', '${service}')
+  _neat_endpoint = ENV.fetch('OTEL_EXPORTER_OTLP_TRACES_ENDPOINT', '${endpoint2}')
+
+  OpenTelemetry::SDK.configure do |c|
+    c.service_name = _neat_service
+    c.use_all
+    c.add_span_processor(
+      OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+        OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint: _neat_endpoint)
+      )
+    )
+    c.add_span_processor(NeatCallSiteSpanProcessor.new(_neat_root))
+  end
+end
+`;
+}
+async function exists6(p) {
+  try {
+    await import_node_fs42.promises.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detect4(serviceDir) {
+  for (const marker of RUBY_MARKERS) {
+    if (await exists6(import_node_path76.default.join(serviceDir, marker))) return true;
+  }
+  return false;
+}
+async function isRailsApp(serviceDir, gemfile) {
+  if (gemfile && /^\s*gem\s+['"]rails['"]/m.test(gemfile)) return true;
+  for (const marker of ["config/application.rb", "config/environment.rb", "bin/rails"]) {
+    if (await exists6(import_node_path76.default.join(serviceDir, marker))) return true;
+  }
+  return false;
+}
+function gemPresent(gemfile, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*gem\\s+['"]${escaped}['"]`, "m").test(gemfile);
+}
+async function readGemfile(serviceDir) {
+  const file = import_node_path76.default.join(serviceDir, "Gemfile");
+  if (!await exists6(file)) return null;
+  return { file, body: await import_node_fs42.promises.readFile(file, "utf8") };
+}
+async function plan4(serviceDir, opts) {
+  const empty = {
+    language: "ruby",
+    serviceDir,
+    dependencyEdits: [],
+    entrypointEdits: [],
+    envEdits: []
+  };
+  const gemfile = await readGemfile(serviceDir);
+  const dependencyEdits = [];
+  if (gemfile) {
+    for (const gem of RUBY_GEMS) {
+      if (!gemPresent(gemfile.body, gem.name)) {
+        dependencyEdits.push({ file: gemfile.file, kind: "add", name: gem.name, version: gem.version });
+      }
+    }
+  }
+  const rails = await isRailsApp(serviceDir, gemfile?.body ?? null);
+  const initializer = import_node_path76.default.join(serviceDir, INITIALIZER_REL);
+  const generatedFiles = [];
+  if (rails && !await exists6(initializer)) {
+    generatedFiles.push({
+      file: initializer,
+      contents: neatOtelRb({ project: opts?.project }),
+      skipIfExists: true
+    });
+  }
+  if (dependencyEdits.length === 0 && generatedFiles.length === 0) {
+    return empty;
+  }
+  const envEdits = [
+    { file: null, key: "OTEL_EXPORTER_OTLP_ENDPOINT", value: "http://localhost:4318" }
+  ];
+  return {
+    language: "ruby",
+    serviceDir,
+    dependencyEdits,
+    entrypointEdits: [],
+    envEdits,
+    ...generatedFiles.length > 0 ? { generatedFiles } : {}
+  };
+}
+async function writeFileAtomic2(file, contents) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await import_node_fs42.promises.writeFile(tmp, contents, "utf8");
+  await import_node_fs42.promises.rename(tmp, file);
+}
+async function applyGemfile(file, edits, original) {
+  const lines = edits.filter((e) => e.kind === "add").map((e) => `gem '${e.name}', '${e.version}'`);
+  const banner = `
+# ${NEAT_OTEL_STAMP2} \u2014 OpenTelemetry gems added by NEAT
+`;
+  const trailing = original.endsWith("\n") ? "" : "\n";
+  await writeFileAtomic2(file, `${original}${trailing}${banner}${lines.join("\n")}
+`);
+}
+async function rollback3(serviceDir, language, originals, created) {
+  const restored = [];
+  for (const [file, raw] of originals.entries()) {
+    try {
+      await import_node_fs42.promises.writeFile(file, raw, "utf8");
+      restored.push(file);
+    } catch {
+    }
+  }
+  const removed = [];
+  for (const file of created) {
+    try {
+      await import_node_fs42.promises.rm(file, { force: true });
+      removed.push(file);
+    } catch {
+    }
+  }
+  const body = [
+    "# neat-rollback.patch",
+    "",
+    `# Generated after a partial apply failure in the ${language} installer.`,
+    "# Files listed below were restored to their pre-apply contents.",
+    "",
+    ...restored.map((f) => `restored: ${f}`),
+    ...removed.map((f) => `removed: ${f}`),
+    ""
+  ];
+  await import_node_fs42.promises.writeFile(import_node_path76.default.join(serviceDir, "neat-rollback.patch"), body.join("\n"), "utf8");
+}
+async function apply4(installPlan) {
+  const { serviceDir } = installPlan;
+  const generatedFiles = installPlan.generatedFiles ?? [];
+  const manifests = new Set(installPlan.dependencyEdits.map((e) => e.file));
+  if (manifests.size === 0 && generatedFiles.length === 0) {
+    return { serviceDir, outcome: "already-instrumented", writtenFiles: [] };
+  }
+  const originals = /* @__PURE__ */ new Map();
+  for (const file of manifests) {
+    try {
+      originals.set(file, await import_node_fs42.promises.readFile(file, "utf8"));
+    } catch {
+    }
+  }
+  const writtenFiles = [];
+  const created = [];
+  try {
+    for (const gf of generatedFiles) {
+      if (await exists6(gf.file)) continue;
+      await import_node_fs42.promises.mkdir(import_node_path76.default.dirname(gf.file), { recursive: true });
+      await writeFileAtomic2(gf.file, gf.contents);
+      writtenFiles.push(gf.file);
+      created.push(gf.file);
+    }
+    for (const file of manifests) {
+      const raw = originals.get(file);
+      if (raw === void 0) throw new Error(`ruby installer: cannot read ${file} during apply`);
+      const edits = installPlan.dependencyEdits.filter((e) => e.file === file);
+      if (edits.length > 0) {
+        await applyGemfile(file, edits, raw);
+        writtenFiles.push(file);
+      }
+    }
+  } catch (err) {
+    await rollback3(serviceDir, installPlan.language, originals, created);
+    throw err;
+  }
+  const wroteManifest = writtenFiles.some((f) => import_node_path76.default.basename(f) === "Gemfile");
+  return {
+    serviceDir,
+    outcome: writtenFiles.length > 0 ? "instrumented" : "already-instrumented",
+    writtenFiles,
+    ...wroteManifest ? { followUpInstall: "bundle install" } : {}
+  };
+}
+var rubyInstaller = { name: "ruby", detect: detect4, plan: plan4, apply: apply4 };
+
+// src/installers/php.ts
+init_cjs_shims();
+var import_node_fs43 = require("fs");
+var import_node_path77 = __toESM(require("path"), 1);
+var PHP_MARKERS = [
+  "composer.json",
+  "composer.lock"
+];
+var NEAT_OTEL_FILENAME2 = "neat_otel.php";
+var NEAT_OTEL_STAMP3 = "neat-otel-init v1";
+var LARAVEL_PACKAGE = "open-telemetry/opentelemetry-auto-laravel";
+var PHP_PACKAGES = [
+  { name: "open-telemetry/sdk", version: "^1.0" },
+  { name: "open-telemetry/exporter-otlp", version: "^1.0" },
+  { name: "php-http/guzzle7-adapter", version: "^1.0" },
+  { name: LARAVEL_PACKAGE, version: "^0.1" }
+];
+var PHP_PECL_CAVEAT = "PHP auto-instrumentation requires the `opentelemetry` PECL extension (`pecl install opentelemetry`, then `extension=opentelemetry.so` in php.ini). NEAT cannot install a PECL extension via composer \u2014 until it is loaded no spans are produced. See neat_otel.php and ADR-186.";
+function neatOtelPhp(opts = {}) {
+  const service = opts.project ?? "php-service";
+  const endpoint2 = opts.project ? `http://localhost:4318/projects/${opts.project}/v1/traces` : "http://localhost:4318/v1/traces";
+  return `<?php
+// ${NEAT_OTEL_STAMP3} \u2014 generated by NEAT. Safe to re-generate; do not edit.
+//
+// REQUIRED SYSTEM STEP \u2014 NEAT CANNOT DO THIS FOR YOU:
+//   PHP OpenTelemetry auto-instrumentation needs the \`opentelemetry\` PECL
+//   extension, a system-level install composer cannot provide:
+//       pecl install opentelemetry
+//   then enable it in your php.ini:
+//       extension=opentelemetry.so
+//   Verify with \`php -m | grep opentelemetry\`. Until the extension is loaded
+//   the Laravel auto-instrumentation hooks never fire and no spans are emitted.
+//
+// Wire this file so it runs before the framework boots \u2014 either set
+//   auto_prepend_file = /absolute/path/to/neat_otel.php
+// in php.ini / .user.ini, or require it at the very top of public/index.php and
+// artisan. It points the exporter at your NEAT daemon and turns on the SDK
+// autoloader; the auto-laravel instrumentation then produces route, DB, cache,
+// and queue spans that fuse onto your extracted routes and Eloquent tables.
+//
+// FILE-GRAIN (code.file.path call-site attribution) is a documented follow-up
+// for PHP \u2014 see ADR-186. Route, table, and service grain land now.
+
+declare(strict_types=1);
+
+// Degrade to a no-op when the extension isn't present, so a bare app still
+// boots (never break the host application).
+if (!extension_loaded('opentelemetry')) {
+    return;
+}
+
+// Point the exporter at NEAT unless the operator already set these. The
+// endpoint is NEAT's project-scoped traces path (ADR-183).
+$neat_defaults = [
+    'OTEL_PHP_AUTOLOAD_ENABLED' => 'true',
+    'OTEL_SERVICE_NAME' => '${service}',
+    'OTEL_TRACES_EXPORTER' => 'otlp',
+    'OTEL_EXPORTER_OTLP_PROTOCOL' => 'http/json',
+    'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT' => '${endpoint2}',
+    'OTEL_PROPAGATORS' => 'baggage,tracecontext',
+];
+foreach ($neat_defaults as $neat_key => $neat_value) {
+    if (getenv($neat_key) === false && !isset($_SERVER[$neat_key]) && !isset($_ENV[$neat_key])) {
+        putenv($neat_key . '=' . $neat_value);
+        $_SERVER[$neat_key] = $neat_value;
+        $_ENV[$neat_key] = $neat_value;
+    }
+}
+`;
+}
+async function exists7(p) {
+  try {
+    await import_node_fs43.promises.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detect5(serviceDir) {
+  for (const marker of PHP_MARKERS) {
+    if (await exists7(import_node_path77.default.join(serviceDir, marker))) return true;
+  }
+  return false;
+}
+function readComposerObject(body) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    parsed = null;
+  }
+  const obj = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  const require2 = obj.require && typeof obj.require === "object" && !Array.isArray(obj.require) ? obj.require : {};
+  const requireDev = obj["require-dev"] && typeof obj["require-dev"] === "object" && !Array.isArray(obj["require-dev"]) ? obj["require-dev"] : {};
+  return { require: require2, requireDev };
+}
+async function plan5(serviceDir, opts) {
+  const empty = {
+    language: "php",
+    serviceDir,
+    dependencyEdits: [],
+    entrypointEdits: [],
+    envEdits: []
+  };
+  const composerPath = import_node_path77.default.join(serviceDir, "composer.json");
+  const hasComposer = await exists7(composerPath);
+  const dependencyEdits = [];
+  if (hasComposer) {
+    const body = await import_node_fs43.promises.readFile(composerPath, "utf8");
+    const { require: require2, requireDev } = readComposerObject(body);
+    const laravel = "laravel/framework" in require2 || "laravel/framework" in requireDev || await exists7(import_node_path77.default.join(serviceDir, "artisan"));
+    const wanted = laravel ? PHP_PACKAGES : PHP_PACKAGES.filter((p) => p.name !== LARAVEL_PACKAGE);
+    for (const pkg of wanted) {
+      if (!(pkg.name in require2)) {
+        dependencyEdits.push({ file: composerPath, kind: "add", name: pkg.name, version: pkg.version });
+      }
+    }
+  }
+  const bootstrap = import_node_path77.default.join(serviceDir, NEAT_OTEL_FILENAME2);
+  const generatedFiles = [];
+  if (hasComposer && !await exists7(bootstrap)) {
+    generatedFiles.push({ file: bootstrap, contents: neatOtelPhp({ project: opts?.project }), skipIfExists: true });
+  }
+  if (dependencyEdits.length === 0 && generatedFiles.length === 0) {
+    return empty;
+  }
+  const envEdits = [
+    { file: null, key: "OTEL_PHP_AUTOLOAD_ENABLED", value: "true" },
+    { file: null, key: "OTEL_EXPORTER_OTLP_ENDPOINT", value: "http://localhost:4318" }
+  ];
+  return {
+    language: "php",
+    serviceDir,
+    dependencyEdits,
+    entrypointEdits: [],
+    envEdits,
+    ...generatedFiles.length > 0 ? { generatedFiles } : {}
+  };
+}
+async function writeFileAtomic3(file, contents) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await import_node_fs43.promises.writeFile(tmp, contents, "utf8");
+  await import_node_fs43.promises.rename(tmp, file);
+}
+async function applyComposerJson(file, edits, original) {
+  let parsed;
+  try {
+    parsed = JSON.parse(original);
+  } catch {
+    throw new Error(`php installer: composer.json at ${file} is not valid JSON`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`php installer: composer.json at ${file} is not a JSON object`);
+  }
+  const obj = parsed;
+  const require2 = obj.require && typeof obj.require === "object" && !Array.isArray(obj.require) ? obj.require : {};
+  for (const e of edits) {
+    if (e.kind !== "add") continue;
+    if (!(e.name in require2)) require2[e.name] = e.version;
+  }
+  obj.require = require2;
+  await writeFileAtomic3(file, JSON.stringify(obj, null, 2) + "\n");
+}
+async function rollback4(serviceDir, language, originals, created) {
+  const restored = [];
+  for (const [file, raw] of originals.entries()) {
+    try {
+      await import_node_fs43.promises.writeFile(file, raw, "utf8");
+      restored.push(file);
+    } catch {
+    }
+  }
+  const removed = [];
+  for (const file of created) {
+    try {
+      await import_node_fs43.promises.rm(file, { force: true });
+      removed.push(file);
+    } catch {
+    }
+  }
+  const body = [
+    "# neat-rollback.patch",
+    "",
+    `# Generated after a partial apply failure in the ${language} installer.`,
+    "# Files listed below were restored to their pre-apply contents.",
+    "",
+    ...restored.map((f) => `restored: ${f}`),
+    ...removed.map((f) => `removed: ${f}`),
+    ""
+  ];
+  await import_node_fs43.promises.writeFile(import_node_path77.default.join(serviceDir, "neat-rollback.patch"), body.join("\n"), "utf8");
+}
+async function apply5(installPlan) {
+  const { serviceDir } = installPlan;
+  const generatedFiles = installPlan.generatedFiles ?? [];
+  const manifests = new Set(installPlan.dependencyEdits.map((e) => e.file));
+  if (manifests.size === 0 && generatedFiles.length === 0) {
+    return { serviceDir, outcome: "already-instrumented", writtenFiles: [], reason: PHP_PECL_CAVEAT };
+  }
+  const originals = /* @__PURE__ */ new Map();
+  for (const file of manifests) {
+    try {
+      originals.set(file, await import_node_fs43.promises.readFile(file, "utf8"));
+    } catch {
+    }
+  }
+  const writtenFiles = [];
+  const created = [];
+  try {
+    for (const gf of generatedFiles) {
+      if (await exists7(gf.file)) continue;
+      await import_node_fs43.promises.mkdir(import_node_path77.default.dirname(gf.file), { recursive: true });
+      await writeFileAtomic3(gf.file, gf.contents);
+      writtenFiles.push(gf.file);
+      created.push(gf.file);
+    }
+    for (const file of manifests) {
+      const raw = originals.get(file);
+      if (raw === void 0) throw new Error(`php installer: cannot read ${file} during apply`);
+      const edits = installPlan.dependencyEdits.filter((e) => e.file === file);
+      if (edits.length > 0) {
+        await applyComposerJson(file, edits, raw);
+        writtenFiles.push(file);
+      }
+    }
+  } catch (err) {
+    await rollback4(serviceDir, installPlan.language, originals, created);
+    throw err;
+  }
+  if (writtenFiles.length > 0) {
+    console.warn(`neat: PHP instrumentation staged in ${import_node_path77.default.basename(serviceDir)}, but a system step remains:
+  ${PHP_PECL_CAVEAT}`);
+  }
+  const wroteManifest = writtenFiles.some((f) => import_node_path77.default.basename(f) === "composer.json");
+  return {
+    serviceDir,
+    outcome: writtenFiles.length > 0 ? "instrumented" : "already-instrumented",
+    writtenFiles,
+    reason: PHP_PECL_CAVEAT,
+    ...wroteManifest ? { followUpInstall: "composer install" } : {}
+  };
+}
+var phpInstaller = { name: "php", detect: detect5, plan: plan5, apply: apply5 };
+
 // src/installers/shared.ts
 init_cjs_shims();
-function isEmptyPlan(plan4) {
-  return plan4.dependencyEdits.length === 0 && plan4.entrypointEdits.length === 0 && plan4.envEdits.length === 0 && (plan4.generatedFiles?.length ?? 0) === 0 && plan4.nextConfigEdit === void 0;
+function isEmptyPlan(plan6) {
+  return plan6.dependencyEdits.length === 0 && plan6.entrypointEdits.length === 0 && plan6.envEdits.length === 0 && (plan6.generatedFiles?.length ?? 0) === 0 && plan6.nextConfigEdit === void 0;
 }
 
 // src/installers/index.ts
@@ -22248,9 +23233,16 @@ var FORBIDDEN_LOCKFILES = /* @__PURE__ */ new Set([
   "Pipfile.lock",
   "Gemfile.lock",
   "Cargo.lock",
-  "go.sum"
+  "go.sum",
+  "composer.lock"
 ]);
-var INSTALLERS = [javascriptInstaller, pythonInstaller, goInstaller];
+var INSTALLERS = [
+  javascriptInstaller,
+  pythonInstaller,
+  goInstaller,
+  rubyInstaller,
+  phpInstaller
+];
 async function pickInstaller(serviceDir) {
   for (const inst of INSTALLERS) {
     if (await inst.detect(serviceDir)) return inst;
@@ -22265,7 +23257,7 @@ function renderPatch(sections) {
       "No SDK installers matched the discovered services. Two reasons this",
       "normally happens:",
       "  - the project uses a language NEAT does not yet instrument",
-      "    (Java / Ruby / .NET / Rust are out of MVP scope per ADR-047);",
+      "    (Java / .NET / Rust are out of scope per ADR-047);",
       "  - the SDK is already installed, so the installer returned an empty",
       "    plan.",
       "",
@@ -22275,22 +23267,22 @@ function renderPatch(sections) {
   }
   const lines = ["# neat install plan", ""];
   for (const section of sections) {
-    const { installer, plan: plan4 } = section;
-    lines.push(`## ${installer} (${plan4.language}) \u2014 ${plan4.serviceDir}`);
+    const { installer, plan: plan6 } = section;
+    lines.push(`## ${installer} (${plan6.language}) \u2014 ${plan6.serviceDir}`);
     lines.push("");
-    if (plan4.libOnly) {
+    if (plan6.libOnly) {
       lines.push("### skipped \u2014 no resolvable entry point (lib-only)");
       lines.push("");
       continue;
     }
-    if (plan4.entryFile) {
-      lines.push(`entry: ${plan4.entryFile}`);
+    if (plan6.entryFile) {
+      lines.push(`entry: ${plan6.entryFile}`);
       lines.push("");
     }
-    if (plan4.dependencyEdits.length > 0) {
+    if (plan6.dependencyEdits.length > 0) {
       lines.push("### dependencies");
       const byFile = /* @__PURE__ */ new Map();
-      for (const dep of plan4.dependencyEdits) {
+      for (const dep of plan6.dependencyEdits) {
         const base = dep.file.split(/[\\/]/).pop() ?? dep.file;
         if (FORBIDDEN_LOCKFILES.has(base)) {
           throw new Error(
@@ -22309,9 +23301,9 @@ function renderPatch(sections) {
       }
       lines.push("");
     }
-    if (plan4.generatedFiles && plan4.generatedFiles.length > 0) {
+    if (plan6.generatedFiles && plan6.generatedFiles.length > 0) {
       lines.push("### generated files");
-      for (const gen of plan4.generatedFiles) {
+      for (const gen of plan6.generatedFiles) {
         lines.push(`--- (new file) ${gen.file}`);
         for (const ln of gen.contents.split(/\r?\n/)) {
           lines.push(`+ ${ln}`);
@@ -22319,26 +23311,26 @@ function renderPatch(sections) {
       }
       lines.push("");
     }
-    if (plan4.entrypointEdits.length > 0) {
+    if (plan6.entrypointEdits.length > 0) {
       lines.push("### entry-point injection");
-      for (const e of plan4.entrypointEdits) {
+      for (const e of plan6.entrypointEdits) {
         lines.push(`--- ${e.file}`);
         lines.push(`+ ${e.after}`);
         lines.push(`  ${e.before}`);
       }
       lines.push("");
     }
-    if (plan4.envEdits.length > 0) {
+    if (plan6.envEdits.length > 0) {
       lines.push("### env (written to <package-dir>/.env.neat)");
-      for (const env of plan4.envEdits) {
+      for (const env of plan6.envEdits) {
         lines.push(`- ${env.key}=${env.value}`);
       }
       lines.push("");
     }
-    if (plan4.nextConfigEdit) {
+    if (plan6.nextConfigEdit) {
       lines.push("### next.config (framework flag)");
-      lines.push(`--- ${plan4.nextConfigEdit.file}`);
-      lines.push(`+ experimental: { instrumentationHook: true }, // ${plan4.nextConfigEdit.reason}`);
+      lines.push(`--- ${plan6.nextConfigEdit.file}`);
+      lines.push(`+ experimental: { instrumentationHook: true }, // ${plan6.nextConfigEdit.reason}`);
       lines.push("");
     }
   }
@@ -22347,10 +23339,10 @@ function renderPatch(sections) {
 
 // src/orchestrator.ts
 init_cjs_shims();
-var import_node_fs42 = require("fs");
+var import_node_fs44 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_net = __toESM(require("net"), 1);
-var import_node_path76 = __toESM(require("path"), 1);
+var import_node_path78 = __toESM(require("path"), 1);
 var import_node_url4 = require("url");
 var import_node_child_process3 = require("child_process");
 var import_node_readline = __toESM(require("readline"), 1);
@@ -22360,7 +23352,7 @@ async function extractAndPersist(opts) {
   const graphKey = opts.projectExplicit ? opts.project : DEFAULT_PROJECT;
   resetGraph(graphKey);
   const graph = getGraph(graphKey);
-  const projectPaths = pathsForProject(graphKey, import_node_path76.default.join(opts.scanPath, "neat-out"));
+  const projectPaths = pathsForProject(graphKey, import_node_path78.default.join(opts.scanPath, "neat-out"));
   const extraction = await extractFromDirectory(graph, opts.scanPath, {
     errorsPath: projectPaths.errorsPath
   });
@@ -22391,28 +23383,34 @@ async function applyInstallersOver(services, project, options = {}) {
   let cloudflareWorkers = 0;
   let electron = 0;
   const installPlans = /* @__PURE__ */ new Map();
+  const dependencyInstructions = /* @__PURE__ */ new Map();
   for (const svc of services) {
     const installer = await pickInstaller(svc.dir);
     if (!installer) continue;
-    const plan4 = await installer.plan(svc.dir, { project });
-    if (isEmptyPlan(plan4) && !plan4.libOnly && plan4.runtimeKind === void 0) {
+    const plan6 = await installer.plan(svc.dir, { project });
+    if (isEmptyPlan(plan6) && !plan6.libOnly && plan6.runtimeKind === void 0) {
       already++;
       continue;
     }
-    const outcome = await installer.apply(plan4);
+    const outcome = await installer.apply(plan6);
     if (outcome.outcome === "instrumented") {
       instrumented++;
-      if (plan4.dependencyEdits.length > 0) {
-        const cmd = await resolveManager(svc.dir);
-        const key = `${cmd.pm}:${cmd.cwd}`;
-        if (!installPlans.has(key)) installPlans.set(key, cmd);
+      if (plan6.dependencyEdits.length > 0) {
+        const manifest = import_node_path78.default.basename(plan6.dependencyEdits[0].file);
+        if (manifest === "package.json") {
+          const cmd = await resolveManager(svc.dir);
+          const key = `${cmd.pm}:${cmd.cwd}`;
+          if (!installPlans.has(key)) installPlans.set(key, cmd);
+        } else if (outcome.followUpInstall) {
+          dependencyInstructions.set(svc.dir, outcome.followUpInstall);
+        }
       }
     } else if (outcome.outcome === "already-instrumented") already++;
     else if (outcome.outcome === "lib-only") {
       libOnly++;
       const appDeps = svc.pkg ? appFrameworkDependencies(svc.pkg) : [];
       if (appDeps.length > 0) {
-        const svcName = import_node_path76.default.basename(svc.dir);
+        const svcName = import_node_path78.default.basename(svc.dir);
         const list = appDeps.join(", ");
         console.warn(
           `neat: runtime layer won't engage for ${svcName}: no entry point found.
@@ -22425,7 +23423,7 @@ async function applyInstallersOver(services, project, options = {}) {
       console.log(`skipping ${svc.dir}: browser bundle; browser-OTel support lands in a future release.`);
     } else if (outcome.outcome === "react-native") {
       reactNative++;
-      const svcName = import_node_path76.default.basename(svc.dir);
+      const svcName = import_node_path78.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as React Native / Expo
   The installer doesn't cover this runtime deterministically.
@@ -22436,7 +23434,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "bun") {
       bun++;
-      const svcName = import_node_path76.default.basename(svc.dir);
+      const svcName = import_node_path78.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Bun
   The installer doesn't cover this runtime deterministically.
@@ -22447,7 +23445,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "deno") {
       deno++;
-      const svcName = import_node_path76.default.basename(svc.dir);
+      const svcName = import_node_path78.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Deno
   The installer doesn't cover this runtime deterministically.
@@ -22458,7 +23456,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "cloudflare-workers") {
       cloudflareWorkers++;
-      const svcName = import_node_path76.default.basename(svc.dir);
+      const svcName = import_node_path78.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Cloudflare Workers
   The installer doesn't cover this runtime deterministically.
@@ -22469,7 +23467,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "electron") {
       electron++;
-      const svcName = import_node_path76.default.basename(svc.dir);
+      const svcName = import_node_path78.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Electron
   The installer doesn't cover this runtime deterministically.
@@ -22482,7 +23480,7 @@ async function applyInstallersOver(services, project, options = {}) {
     if (svc.pkg && (outcome.outcome === "instrumented" || outcome.outcome === "already-instrumented")) {
       const gaps = uninstrumentedLibraries(svc.pkg);
       if (gaps.length > 0) {
-        const svcName = import_node_path76.default.basename(svc.dir);
+        const svcName = import_node_path78.default.basename(svc.dir);
         const list = gaps.join(", ");
         const subject = gaps.length === 1 ? "this library" : "these libraries";
         const aux = gaps.length === 1 ? "isn't" : "aren't";
@@ -22510,6 +23508,11 @@ async function applyInstallersOver(services, project, options = {}) {
       }
     }
   }
+  for (const [dir, command] of dependencyInstructions) {
+    console.log(
+      `neat: dependencies staged in ${dir}; run \`${command}\` to install them \u2014 NEAT does not run it for you.`
+    );
+  }
   return {
     instrumented,
     alreadyInstrumented: already,
@@ -22520,7 +23523,8 @@ async function applyInstallersOver(services, project, options = {}) {
     deno,
     cloudflareWorkers,
     electron,
-    packageManagerInstalls
+    packageManagerInstalls,
+    dependencyInstructions: [...dependencyInstructions].map(([dir, command]) => ({ dir, command }))
   };
 }
 async function promptYesNo(question) {
@@ -22688,24 +23692,24 @@ async function persistedPortsFor(scanPath) {
   return { rest: record.ports.rest, otlp: record.ports.otlp, web: record.ports.web };
 }
 async function acquireSpawnLock(scanPath) {
-  const lockPath = import_node_path76.default.join(scanPath, "neat-out", "daemon.spawn.lock");
-  await import_node_fs42.promises.mkdir(import_node_path76.default.dirname(lockPath), { recursive: true });
+  const lockPath = import_node_path78.default.join(scanPath, "neat-out", "daemon.spawn.lock");
+  await import_node_fs44.promises.mkdir(import_node_path78.default.dirname(lockPath), { recursive: true });
   const STALE_LOCK_MS = 6e4;
   try {
-    const fd = await import_node_fs42.promises.open(lockPath, "wx");
+    const fd = await import_node_fs44.promises.open(lockPath, "wx");
     await fd.writeFile(`${process.pid}
 `, "utf8");
     await fd.close();
     return async () => {
-      await import_node_fs42.promises.unlink(lockPath).catch(() => {
+      await import_node_fs44.promises.unlink(lockPath).catch(() => {
       });
     };
   } catch (err) {
     if (err.code !== "EEXIST") return null;
     try {
-      const stat = await import_node_fs42.promises.stat(lockPath);
+      const stat = await import_node_fs44.promises.stat(lockPath);
       if (Date.now() - stat.mtimeMs > STALE_LOCK_MS) {
-        await import_node_fs42.promises.unlink(lockPath).catch(() => {
+        await import_node_fs44.promises.unlink(lockPath).catch(() => {
         });
         return acquireSpawnLock(scanPath);
       }
@@ -22734,13 +23738,13 @@ async function healthIsForProject(restPort, project) {
   return false;
 }
 function daemonLogPath(projectPath3) {
-  return import_node_path76.default.join(projectPath3, "neat-out", "daemon.log");
+  return import_node_path78.default.join(projectPath3, "neat-out", "daemon.log");
 }
 function spawnDaemonDetached(spec) {
-  const here = import_node_path76.default.dirname((0, import_node_url4.fileURLToPath)(importMetaUrl));
+  const here = import_node_path78.default.dirname((0, import_node_url4.fileURLToPath)(importMetaUrl));
   const candidates = [
-    import_node_path76.default.join(here, "neatd.cjs"),
-    import_node_path76.default.join(here, "neatd.js")
+    import_node_path78.default.join(here, "neatd.cjs"),
+    import_node_path78.default.join(here, "neatd.js")
   ];
   let entry2 = null;
   const fsSync = require("fs");
@@ -22770,7 +23774,7 @@ function spawnDaemonDetached(spec) {
   let logFd = null;
   if (spec) {
     const logPath = daemonLogPath(spec.projectPath);
-    fsSync.mkdirSync(import_node_path76.default.dirname(logPath), { recursive: true });
+    fsSync.mkdirSync(import_node_path78.default.dirname(logPath), { recursive: true });
     logFd = fsSync.openSync(logPath, "a");
   }
   const child = (0, import_node_child_process3.spawn)(process.execPath, [entry2, "start"], {
@@ -22809,7 +23813,7 @@ async function runOrchestrator(opts) {
       browser: "skipped"
     }
   };
-  const stat = await import_node_fs42.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs44.promises.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat: ${opts.scanPath} is not a directory`);
     result.exitCode = 2;
@@ -22969,7 +23973,7 @@ async function runOrchestrator(opts) {
     result.steps.browser = openBrowser(dashboardUrl);
   }
   const daemonRunning = result.steps.daemon === "spawned" || result.steps.daemon === "already-running";
-  const daemonLog = daemonRunning ? import_node_path76.default.relative(opts.scanPath, daemonLogPath(opts.scanPath)) : null;
+  const daemonLog = daemonRunning ? import_node_path78.default.relative(opts.scanPath, daemonLogPath(opts.scanPath)) : null;
   printSummary(result, graph, dashboardUrl, daemonLog);
   return result;
 }
@@ -23428,27 +24432,27 @@ async function runConnectorCommand(rawArgs, deps = {}) {
 
 // src/hooks-cli.ts
 init_cjs_shims();
-var import_node_path77 = __toESM(require("path"), 1);
+var import_node_path79 = __toESM(require("path"), 1);
 var import_node_os5 = __toESM(require("os"), 1);
-var import_node_fs43 = require("fs");
+var import_node_fs45 = require("fs");
 var import_node_url5 = require("url");
 var HOOK_FILENAME = "neat-search-nudge.mjs";
 var GUIDE_FILENAME = "GRAPH_FIRST.md";
 var GUIDE_INSTALL_NAME = "neat-graph-first.md";
 var HOOK_MATCHER = "Grep|Glob|Bash";
 function moduleDir() {
-  return typeof __dirname !== "undefined" ? __dirname : import_node_path77.default.dirname((0, import_node_url5.fileURLToPath)(importMetaUrl));
+  return typeof __dirname !== "undefined" ? __dirname : import_node_path79.default.dirname((0, import_node_url5.fileURLToPath)(importMetaUrl));
 }
 async function readSkillAsset(rel) {
   const here = moduleDir();
   const candidates = [
-    import_node_path77.default.resolve(here, "../../claude-skill", rel),
-    import_node_path77.default.resolve(here, "../../../claude-skill", rel),
-    import_node_path77.default.resolve(here, "../claude-skill", rel)
+    import_node_path79.default.resolve(here, "../../claude-skill", rel),
+    import_node_path79.default.resolve(here, "../../../claude-skill", rel),
+    import_node_path79.default.resolve(here, "../claude-skill", rel)
   ];
   for (const candidate of candidates) {
     try {
-      return await import_node_fs43.promises.readFile(candidate, "utf8");
+      return await import_node_fs45.promises.readFile(candidate, "utf8");
     } catch {
     }
   }
@@ -23458,17 +24462,17 @@ async function readSkillAsset(rel) {
 }
 function neatHome3() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path77.default.resolve(override);
-  return import_node_path77.default.join(import_node_os5.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path79.default.resolve(override);
+  return import_node_path79.default.join(import_node_os5.default.homedir(), ".neat");
 }
 function claudeSettingsPath() {
   const override = process.env.NEAT_CLAUDE_SETTINGS;
-  if (override && override.length > 0) return import_node_path77.default.resolve(override);
+  if (override && override.length > 0) return import_node_path79.default.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? import_node_os5.default.homedir();
-  return import_node_path77.default.join(home, ".claude", "settings.json");
+  return import_node_path79.default.join(home, ".claude", "settings.json");
 }
 function installedHookPath() {
-  return import_node_path77.default.join(neatHome3(), "hooks", HOOK_FILENAME);
+  return import_node_path79.default.join(neatHome3(), "hooks", HOOK_FILENAME);
 }
 function isNeatSearchEntry(entry2) {
   return (entry2.hooks ?? []).some(
@@ -23501,14 +24505,14 @@ async function runHooks(opts) {
     const hookScript = await readSkillAsset(`hooks/${HOOK_FILENAME}`);
     const guide = await readSkillAsset(GUIDE_FILENAME);
     const scriptPath = installedHookPath();
-    await import_node_fs43.promises.mkdir(import_node_path77.default.dirname(scriptPath), { recursive: true });
-    await import_node_fs43.promises.writeFile(scriptPath, hookScript, { mode: 493 });
-    const guidePath = import_node_path77.default.join(neatHome3(), GUIDE_INSTALL_NAME);
-    await import_node_fs43.promises.writeFile(guidePath, guide, "utf8");
+    await import_node_fs45.promises.mkdir(import_node_path79.default.dirname(scriptPath), { recursive: true });
+    await import_node_fs45.promises.writeFile(scriptPath, hookScript, { mode: 493 });
+    const guidePath = import_node_path79.default.join(neatHome3(), GUIDE_INSTALL_NAME);
+    await import_node_fs45.promises.writeFile(guidePath, guide, "utf8");
     const settingsFile = claudeSettingsPath();
     let settings = {};
     try {
-      settings = JSON.parse(await import_node_fs43.promises.readFile(settingsFile, "utf8"));
+      settings = JSON.parse(await import_node_fs45.promises.readFile(settingsFile, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(
@@ -23530,8 +24534,8 @@ async function runHooks(opts) {
       ...settings,
       hooks: { ...hooks, PreToolUse: preToolUse }
     };
-    await import_node_fs43.promises.mkdir(import_node_path77.default.dirname(settingsFile), { recursive: true });
-    await import_node_fs43.promises.writeFile(settingsFile, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    await import_node_fs45.promises.mkdir(import_node_path79.default.dirname(settingsFile), { recursive: true });
+    await import_node_fs45.promises.writeFile(settingsFile, JSON.stringify(merged, null, 2) + "\n", "utf8");
     console.log(`neat hooks: installed the search-nudge hook`);
     console.log(`  script:   ${scriptPath}`);
     console.log(`  settings: ${settingsFile} (PreToolUse \u2192 ${HOOK_MATCHER})`);
@@ -23602,9 +24606,9 @@ async function runHooksCommand(args) {
 
 // src/codex-cli.ts
 init_cjs_shims();
-var import_node_path78 = __toESM(require("path"), 1);
+var import_node_path80 = __toESM(require("path"), 1);
 var import_node_os6 = __toESM(require("os"), 1);
-var import_node_fs44 = require("fs");
+var import_node_fs46 = require("fs");
 var import_node_util = require("util");
 var import_smol_toml5 = require("smol-toml");
 var CODEX_MCP_SERVER = {
@@ -23622,14 +24626,14 @@ var NEAT_GRAPH_FIRST_START = "<!-- neat:graph-first -->";
 var NEAT_GRAPH_FIRST_END = "<!-- /neat:graph-first -->";
 function codexConfigPath() {
   const override = process.env.NEAT_CODEX_CONFIG;
-  if (override && override.length > 0) return import_node_path78.default.resolve(override);
+  if (override && override.length > 0) return import_node_path80.default.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? import_node_os6.default.homedir();
-  return import_node_path78.default.join(home, ".codex", "config.toml");
+  return import_node_path80.default.join(home, ".codex", "config.toml");
 }
 function agentsFilePath() {
   const override = process.env.NEAT_CODEX_AGENTS;
-  if (override && override.length > 0) return import_node_path78.default.resolve(override);
-  return import_node_path78.default.join(process.cwd(), "AGENTS.md");
+  if (override && override.length > 0) return import_node_path80.default.resolve(override);
+  return import_node_path80.default.join(process.cwd(), "AGENTS.md");
 }
 function isTableHeader(line) {
   return /^\s*\[\[?[^\]]+\]\]?\s*$/.test(line);
@@ -23763,7 +24767,7 @@ async function runCodex(opts) {
   const agentsPath = agentsFilePath();
   let configRaw = "";
   try {
-    configRaw = await import_node_fs44.promises.readFile(configPath, "utf8");
+    configRaw = await import_node_fs46.promises.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error(`neat codex: failed to read ${configPath} \u2014 ${err.message}`);
@@ -23772,7 +24776,7 @@ async function runCodex(opts) {
   }
   let agentsRaw = "";
   try {
-    agentsRaw = await import_node_fs44.promises.readFile(agentsPath, "utf8");
+    agentsRaw = await import_node_fs46.promises.readFile(agentsPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error(`neat codex: failed to read ${agentsPath} \u2014 ${err.message}`);
@@ -23812,15 +24816,15 @@ async function runCodex(opts) {
     return { exitCode: 0 };
   }
   if (config.changed) {
-    await import_node_fs44.promises.mkdir(import_node_path78.default.dirname(configPath), { recursive: true });
-    await import_node_fs44.promises.writeFile(configPath, config.text, "utf8");
+    await import_node_fs46.promises.mkdir(import_node_path80.default.dirname(configPath), { recursive: true });
+    await import_node_fs46.promises.writeFile(configPath, config.text, "utf8");
     console.log(`neat codex: wrote [mcp_servers.neat] to ${configPath}`);
   } else {
     console.log(`neat codex: ${configPath} already has NEAT's MCP server`);
   }
   if (agents.changed) {
-    await import_node_fs44.promises.mkdir(import_node_path78.default.dirname(agentsPath), { recursive: true });
-    await import_node_fs44.promises.writeFile(agentsPath, agents.text, "utf8");
+    await import_node_fs46.promises.mkdir(import_node_path80.default.dirname(agentsPath), { recursive: true });
+    await import_node_fs46.promises.writeFile(agentsPath, agents.text, "utf8");
     console.log(`neat codex: wrote the graph-first block to ${agentsPath}`);
   } else {
     console.log(`neat codex: ${agentsPath} already has the graph-first block`);
@@ -23877,9 +24881,9 @@ async function runCodexCommand(args) {
 
 // src/editors-cli.ts
 init_cjs_shims();
-var import_node_path79 = __toESM(require("path"), 1);
+var import_node_path81 = __toESM(require("path"), 1);
 var import_node_os7 = __toESM(require("os"), 1);
-var import_node_fs45 = require("fs");
+var import_node_fs47 = require("fs");
 var import_node_util2 = require("util");
 var jsonc = __toESM(require("jsonc-parser"), 1);
 var NEAT_MCP_SERVER = {
@@ -23903,17 +24907,17 @@ function homeDir() {
 }
 function xdgConfigDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  return xdg && xdg.length > 0 ? import_node_path79.default.resolve(xdg) : import_node_path79.default.join(homeDir(), ".config");
+  return xdg && xdg.length > 0 ? import_node_path81.default.resolve(xdg) : import_node_path81.default.join(homeDir(), ".config");
 }
 function envOverride(name) {
   const v = process.env[name];
-  return v && v.length > 0 ? import_node_path79.default.resolve(v) : void 0;
+  return v && v.length > 0 ? import_node_path81.default.resolve(v) : void 0;
 }
 var CURSOR_CLIENT = {
   id: "cursor",
   label: "Cursor",
   docsUrl: "https://docs.cursor.com/context/mcp",
-  mcpConfigPath: () => envOverride("NEAT_CURSOR_CONFIG") ?? import_node_path79.default.join(homeDir(), ".cursor", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_CURSOR_CONFIG") ?? import_node_path81.default.join(homeDir(), ".cursor", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   // Cursor still reads a single `.cursorrules` at the project root (the modern
@@ -23925,7 +24929,7 @@ var DEVIN_CLIENT = {
   id: "devin",
   label: "Devin Desktop (Cascade)",
   docsUrl: "https://docs.devin.ai/desktop/cascade/mcp",
-  mcpConfigPath: () => envOverride("NEAT_DEVIN_CONFIG") ?? import_node_path79.default.join(homeDir(), ".codeium", "windsurf", "mcp_config.json"),
+  mcpConfigPath: () => envOverride("NEAT_DEVIN_CONFIG") ?? import_node_path81.default.join(homeDir(), ".codeium", "windsurf", "mcp_config.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: ".windsurfrules"
@@ -23934,7 +24938,7 @@ var GEMINI_CLIENT = {
   id: "gemini",
   label: "Gemini CLI",
   docsUrl: "https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md",
-  mcpConfigPath: () => envOverride("NEAT_GEMINI_CONFIG") ?? import_node_path79.default.join(homeDir(), ".gemini", "settings.json"),
+  mcpConfigPath: () => envOverride("NEAT_GEMINI_CONFIG") ?? import_node_path81.default.join(homeDir(), ".gemini", "settings.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: "GEMINI.md"
@@ -23943,7 +24947,7 @@ var QWEN_CLIENT = {
   id: "qwen",
   label: "Qwen Code",
   docsUrl: "https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/",
-  mcpConfigPath: () => envOverride("NEAT_QWEN_CONFIG") ?? import_node_path79.default.join(homeDir(), ".qwen", "settings.json"),
+  mcpConfigPath: () => envOverride("NEAT_QWEN_CONFIG") ?? import_node_path81.default.join(homeDir(), ".qwen", "settings.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: "QWEN.md"
@@ -23952,7 +24956,7 @@ var AMAZONQ_CLIENT = {
   id: "amazonq",
   label: "Amazon Q Developer CLI",
   docsUrl: "https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-configuration.html",
-  mcpConfigPath: () => envOverride("NEAT_AMAZONQ_CONFIG") ?? import_node_path79.default.join(homeDir(), ".aws", "amazonq", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_AMAZONQ_CONFIG") ?? import_node_path81.default.join(homeDir(), ".aws", "amazonq", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json"
 };
@@ -23960,7 +24964,7 @@ var ROOCODE_CLIENT = {
   id: "roocode",
   label: "Roo Code",
   docsUrl: "https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo",
-  mcpConfigPath: () => envOverride("NEAT_ROOCODE_CONFIG") ?? import_node_path79.default.join(process.cwd(), ".roo", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_ROOCODE_CONFIG") ?? import_node_path81.default.join(process.cwd(), ".roo", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json"
 };
@@ -23973,9 +24977,9 @@ var ZED_CLIENT = {
     if (override) return override;
     if (process.platform === "win32") {
       const appData = process.env.APPDATA;
-      if (appData && appData.length > 0) return import_node_path79.default.join(appData, "Zed", "settings.json");
+      if (appData && appData.length > 0) return import_node_path81.default.join(appData, "Zed", "settings.json");
     }
-    return import_node_path79.default.join(homeDir(), ".config", "zed", "settings.json");
+    return import_node_path81.default.join(homeDir(), ".config", "zed", "settings.json");
   },
   mcpContainerKey: "context_servers",
   format: "jsonc",
@@ -23985,7 +24989,7 @@ var OPENCODE_CLIENT = {
   id: "opencode",
   label: "OpenCode",
   docsUrl: "https://opencode.ai/docs/mcp-servers/",
-  mcpConfigPath: () => envOverride("NEAT_OPENCODE_CONFIG") ?? import_node_path79.default.join(xdgConfigDir(), "opencode", "opencode.json"),
+  mcpConfigPath: () => envOverride("NEAT_OPENCODE_CONFIG") ?? import_node_path81.default.join(xdgConfigDir(), "opencode", "opencode.json"),
   mcpContainerKey: "mcp",
   format: "json",
   serverEntry: NEAT_OPENCODE_SERVER,
@@ -23995,7 +24999,7 @@ var CRUSH_CLIENT = {
   id: "crush",
   label: "Crush",
   docsUrl: "https://charmbracelet-crush.mintlify.app/configuration/mcp",
-  mcpConfigPath: () => envOverride("NEAT_CRUSH_CONFIG") ?? import_node_path79.default.join(xdgConfigDir(), "crush", "crush.json"),
+  mcpConfigPath: () => envOverride("NEAT_CRUSH_CONFIG") ?? import_node_path81.default.join(xdgConfigDir(), "crush", "crush.json"),
   mcpContainerKey: "mcp",
   format: "json",
   serverEntry: NEAT_CRUSH_SERVER,
@@ -24058,7 +25062,7 @@ async function planMcp(client, mcpPath) {
   const serverEntry = client.serverEntry ?? NEAT_MCP_SERVER;
   let raw = "";
   try {
-    raw = await import_node_fs45.promises.readFile(mcpPath, "utf8");
+    raw = await import_node_fs47.promises.readFile(mcpPath, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -24100,7 +25104,7 @@ async function runEditorInstall(client, opts) {
   const mcpPath = client.mcpConfigPath();
   const serverEntry = client.serverEntry ?? NEAT_MCP_SERVER;
   const hasRules = typeof client.rulesFileName === "string";
-  const rulesPath = hasRules ? import_node_path79.default.join(opts.projectDir, client.rulesFileName) : "";
+  const rulesPath = hasRules ? import_node_path81.default.join(opts.projectDir, client.rulesFileName) : "";
   const mcp = await planMcp(client, mcpPath);
   if (mcp === null) return { exitCode: 1 };
   let existingRules = "";
@@ -24109,7 +25113,7 @@ async function runEditorInstall(client, opts) {
   let block = "";
   if (hasRules) {
     try {
-      existingRules = await import_node_fs45.promises.readFile(rulesPath, "utf8");
+      existingRules = await import_node_fs47.promises.readFile(rulesPath, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat ${client.id}: failed to read ${rulesPath} \u2014 ${err.message}`);
@@ -24143,11 +25147,11 @@ async function runEditorInstall(client, opts) {
     );
     return { exitCode: 0 };
   }
-  await import_node_fs45.promises.mkdir(import_node_path79.default.dirname(mcpPath), { recursive: true });
-  await import_node_fs45.promises.writeFile(mcpPath, mcp.text, "utf8");
+  await import_node_fs47.promises.mkdir(import_node_path81.default.dirname(mcpPath), { recursive: true });
+  await import_node_fs47.promises.writeFile(mcpPath, mcp.text, "utf8");
   if (hasRules) {
-    await import_node_fs45.promises.mkdir(import_node_path79.default.dirname(rulesPath), { recursive: true });
-    await import_node_fs45.promises.writeFile(rulesPath, newRules, "utf8");
+    await import_node_fs47.promises.mkdir(import_node_path81.default.dirname(rulesPath), { recursive: true });
+    await import_node_fs47.promises.writeFile(rulesPath, newRules, "utf8");
   }
   console.log(`neat ${client.id}: wired NEAT into ${client.label}`);
   console.log(`  MCP server: ${mcpPath} (${client.mcpContainerKey}.neat \u2192 npx -y @neat.is/mcp)`);
@@ -24183,11 +25187,11 @@ function usage3(client) {
 }
 async function runEditorCommand(clientId, args, projectDir = process.cwd()) {
   const client = CLIENTS[clientId];
-  let apply4 = false;
+  let apply6 = false;
   for (const arg of args) {
     switch (arg) {
       case "--apply":
-        apply4 = true;
+        apply6 = true;
         break;
       case "-h":
       case "--help":
@@ -24200,7 +25204,7 @@ async function runEditorCommand(clientId, args, projectDir = process.cwd()) {
     }
   }
   try {
-    const { exitCode } = await runEditorInstall(client, { apply: apply4, projectDir });
+    const { exitCode } = await runEditorInstall(client, { apply: apply6, projectDir });
     return exitCode;
   } catch (err) {
     console.error(err.message);
@@ -24210,11 +25214,11 @@ async function runEditorCommand(clientId, args, projectDir = process.cwd()) {
 
 // src/monitor.ts
 init_cjs_shims();
-var import_types84 = require("@neat.is/types");
+var import_types89 = require("@neat.is/types");
 
 // src/cli-client.ts
 init_cjs_shims();
-var import_types83 = require("@neat.is/types");
+var import_types88 = require("@neat.is/types");
 var HttpError = class extends Error {
   constructor(status2, message, responseBody = "") {
     super(message);
@@ -24239,10 +25243,10 @@ function createHttpClient(baseUrl, bearerToken) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path82) {
+    async get(path84) {
       let res;
       try {
-        res = await fetch(`${root}${path82}`, {
+        res = await fetch(`${root}${path84}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -24254,16 +25258,16 @@ function createHttpClient(baseUrl, bearerToken) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path82}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path84}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path82, body) {
+    async post(path84, body) {
       let res;
       try {
-        res = await fetch(`${root}${path82}`, {
+        res = await fetch(`${root}${path84}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -24277,7 +25281,7 @@ function createHttpClient(baseUrl, bearerToken) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path82}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path84}: ${text}`,
           text
         );
       }
@@ -24291,12 +25295,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path82 = projectPath(
+  const path84 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path82);
+    const result = await client.get(path84);
     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}.` : "");
@@ -24322,12 +25326,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path82 = projectPath(
+  const path84 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path82);
+    const result = await client.get(path84);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no dependents. Nothing else would break if it failed.`
@@ -24356,17 +25360,17 @@ async function runBlastRadius(client, input) {
   }
 }
 function formatBlastEntry(n) {
-  const tag = n.edgeProvenance === import_types83.Provenance.STALE ? " [STALE \u2014 last seen too long ago]" : "";
+  const tag = n.edgeProvenance === import_types88.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 path82 = projectPath(
+  const path84 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path82);
+    const result = await client.get(path84);
     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}).`
@@ -24413,7 +25417,7 @@ async function runObservedDependencies(client, input) {
       if (result.observed) {
         return {
           summary: `${input.nodeId} makes no outbound runtime calls, but OTel has observed it receiving traffic on ${result.inboundObservedCount} inbound call path${result.inboundObservedCount === 1 ? "" : "s"} \u2014 it's a pure receiver.`,
-          provenance: import_types83.Provenance.OBSERVED
+          provenance: import_types88.Provenance.OBSERVED
         };
       }
       const note = result.hasExtractedOutbound ? " Static (EXTRACTED) dependencies exist but no runtime traffic has been seen \u2014 is OTel running?" : "";
@@ -24423,7 +25427,7 @@ async function runObservedDependencies(client, input) {
     return {
       summary: `${input.nodeId} has ${result.dependencies.length} runtime dependenc${result.dependencies.length === 1 ? "y" : "ies"} confirmed by OTel.`,
       block: blockLines.join("\n"),
-      provenance: import_types83.Provenance.OBSERVED
+      provenance: import_types88.Provenance.OBSERVED
     };
   } catch (err) {
     if (err instanceof HttpError && err.status === 404) {
@@ -24458,9 +25462,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path82 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
+  const path84 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
   try {
-    const body = await client.get(path82);
+    const body = await client.get(path84);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -24477,7 +25481,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_types83.Provenance.OBSERVED
+      provenance: import_types88.Provenance.OBSERVED
     };
   } catch (err) {
     if (err instanceof HttpError && err.status === 404) {
@@ -24586,7 +25590,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_types83.Provenance.STALE
+    provenance: import_types88.Provenance.STALE
   };
 }
 async function runPolicies(client, input) {
@@ -24745,10 +25749,10 @@ async function pushSnapshotToRemote(input) {
 
 // src/monitor.ts
 var OBSERVED_DEP_EDGE_TYPES = /* @__PURE__ */ new Set([
-  import_types84.EdgeType.CALLS,
-  import_types84.EdgeType.CONNECTS_TO,
-  import_types84.EdgeType.PUBLISHES_TO,
-  import_types84.EdgeType.CONSUMES_FROM
+  import_types89.EdgeType.CALLS,
+  import_types89.EdgeType.CONNECTS_TO,
+  import_types89.EdgeType.PUBLISHES_TO,
+  import_types89.EdgeType.CONSUMES_FROM
 ]);
 function divergenceKey(d) {
   const column = "column" in d && d.column ? d.column : "";
@@ -24793,7 +25797,7 @@ function formatDivergenceLine2(d) {
   }
 }
 function formatStaleLine(edgeId) {
-  const parsed = (0, import_types84.parseEdgeId)(edgeId);
+  const parsed = (0, import_types89.parseEdgeId)(edgeId);
   if (parsed) {
     return `\u22EF stale  ${parsed.source} \u2192 ${parsed.target}  (observed edge went quiet)`;
   }
@@ -24806,7 +25810,7 @@ function divergenceJson(d) {
   return JSON.stringify({ kind: "divergence", ...d });
 }
 function staleJson(edgeId) {
-  const parsed = (0, import_types84.parseEdgeId)(edgeId);
+  const parsed = (0, import_types89.parseEdgeId)(edgeId);
   return JSON.stringify({
     kind: "stale",
     edgeId,
@@ -24876,7 +25880,7 @@ var MonitorEmitter = class {
   // ignores non-OBSERVED edges and non-dependency edge types (structural
   // ownership), so only real runtime dependencies reach stdout.
   emitObservedEdge(edge) {
-    if (edge.provenance !== import_types84.Provenance.OBSERVED) return false;
+    if (edge.provenance !== import_types89.Provenance.OBSERVED) return false;
     if (!OBSERVED_DEP_EDGE_TYPES.has(edge.type)) return false;
     const key = `edge|${edge.id}`;
     if (this.seen.has(key)) return false;
@@ -25034,7 +26038,7 @@ async function runMonitor(opts) {
       case "edge-added": {
         const payload = safeParse(frame.data);
         const edge = payload?.edge;
-        if (edge && edge.provenance === import_types84.Provenance.OBSERVED) {
+        if (edge && edge.provenance === import_types89.Provenance.OBSERVED) {
           emitter.emitObservedEdge(edge);
           divergences.schedule();
         }
@@ -25114,7 +26118,7 @@ function sleep(ms, signal) {
 
 // src/cli-verbs.ts
 init_cjs_shims();
-var import_node_path80 = __toESM(require("path"), 1);
+var import_node_path82 = __toESM(require("path"), 1);
 async function resolveProjectEntry(opts) {
   const entries = await listProjects();
   if (opts.project) {
@@ -25124,7 +26128,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_path80.default.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${import_node_path82.default.sep}`)) {
       return entry2;
     }
   }
@@ -25277,7 +26281,7 @@ async function runSync(opts) {
 }
 
 // src/cli.ts
-var import_types85 = require("@neat.is/types");
+var import_types90 = require("@neat.is/types");
 function isNpxInvocation() {
   if (process.env.npm_command === "exec") return true;
   const execpath = process.env.npm_execpath ?? "";
@@ -25631,15 +26635,15 @@ async function buildPatchSections(services, project) {
   for (const svc of services) {
     const installer = await pickInstaller(svc.dir);
     if (!installer) continue;
-    const plan4 = await installer.plan(svc.dir, { project });
-    if (isEmptyPlan(plan4) && !plan4.libOnly && plan4.runtimeKind === void 0) continue;
-    sections.push({ installer: installer.name, plan: plan4 });
+    const plan6 = await installer.plan(svc.dir, { project });
+    if (isEmptyPlan(plan6) && !plan6.libOnly && plan6.runtimeKind === void 0) continue;
+    sections.push({ installer: installer.name, plan: plan6 });
   }
   return sections;
 }
 async function runInit(opts) {
   const written = [];
-  const stat = await import_node_fs46.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs48.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 };
@@ -25648,13 +26652,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_path81.default.join(opts.scanPath, "neat.patch");
+  const patchPath = import_node_path83.default.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
-    await import_node_fs46.promises.writeFile(patchPath, patch, "utf8");
+    await import_node_fs48.promises.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = import_node_path81.default.join(opts.scanPath, ".gitignore");
-    const gitignoreExists = await import_node_fs46.promises.stat(gitignorePath).then(() => true).catch(() => false);
+    const gitignorePath = import_node_path83.default.join(opts.scanPath, ".gitignore");
+    const gitignoreExists = await import_node_fs48.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.");
@@ -25665,9 +26669,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    import_node_path81.default.join(opts.scanPath, "neat-out")
+    import_node_path83.default.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = import_node_path81.default.join(import_node_path81.default.dirname(opts.outPath), import_node_path81.default.basename(projectPaths.errorsPath));
+  const errorsPath = import_node_path83.default.join(import_node_path83.default.dirname(opts.outPath), import_node_path83.default.basename(projectPaths.errorsPath));
   const result = await extractFromDirectory(graph, opts.scanPath, { errorsPath });
   await saveGraphToDisk(graph, opts.outPath);
   written.push(opts.outPath);
@@ -25746,7 +26750,7 @@ async function runInit(opts) {
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
-      await import_node_fs46.promises.writeFile(patchPath, patch, "utf8");
+      await import_node_fs48.promises.writeFile(patchPath, patch, "utf8");
       written.push(patchPath);
     }
   }
@@ -25786,9 +26790,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return import_node_path81.default.resolve(override);
+  if (override && override.length > 0) return import_node_path83.default.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path81.default.join(home, ".claude.json");
+  return import_node_path83.default.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet2 = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -25800,7 +26804,7 @@ async function runSkill(opts) {
     const target = claudeConfigPath();
     let existing = {};
     try {
-      existing = JSON.parse(await import_node_fs46.promises.readFile(target, "utf8"));
+      existing = JSON.parse(await import_node_fs48.promises.readFile(target, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
@@ -25812,8 +26816,8 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await import_node_fs46.promises.mkdir(import_node_path81.default.dirname(target), { recursive: true });
-    await import_node_fs46.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    await import_node_fs48.promises.mkdir(import_node_path83.default.dirname(target), { recursive: true });
+    await import_node_fs48.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.");
     console.log("");
@@ -25886,7 +26890,7 @@ async function main() {
   }
   const cmd = argvParsed.positional[0];
   const parsed = { ...argvParsed, positional: argvParsed.positional.slice(1) };
-  const { positional, apply: apply4, dryRun, noInstall } = parsed;
+  const { positional, apply: apply6, dryRun, noInstall } = parsed;
   const project = parsed.project ?? DEFAULT_PROJECT;
   if (cmd === "init") {
     const target = positional[0];
@@ -25895,22 +26899,22 @@ async function main() {
       usage4();
       process.exit(2);
     }
-    if (apply4 && dryRun) {
+    if (apply6 && dryRun) {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = import_node_path81.default.resolve(target);
+    const scanPath = import_node_path83.default.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : import_node_path81.default.basename(scanPath);
+    const projectName = projectExplicit ? project : import_node_path83.default.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, import_node_path81.default.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = import_node_path81.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const fallback = pathsForProject(projectKey, import_node_path83.default.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = import_node_path83.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
     const result = await runInit({
       scanPath,
       outPath,
       project: projectName,
       projectExplicit,
-      apply: apply4,
+      apply: apply6,
       dryRun,
       noInstall,
       verbose: parsed.verbose
@@ -25925,21 +26929,21 @@ async function main() {
       usage4();
       process.exit(2);
     }
-    const scanPath = import_node_path81.default.resolve(target);
-    const stat = await import_node_fs46.promises.stat(scanPath).catch(() => null);
+    const scanPath = import_node_path83.default.resolve(target);
+    const stat = await import_node_fs48.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_path81.default.join(scanPath, "neat-out"));
-    const outPath = import_node_path81.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = import_node_path81.default.resolve(
-      process.env.NEAT_ERRORS_PATH ?? import_node_path81.default.join(import_node_path81.default.dirname(outPath), import_node_path81.default.basename(projectPaths.errorsPath))
+    const projectPaths = pathsForProject(project, import_node_path83.default.join(scanPath, "neat-out"));
+    const outPath = import_node_path83.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = import_node_path83.default.resolve(
+      process.env.NEAT_ERRORS_PATH ?? import_node_path83.default.join(import_node_path83.default.dirname(outPath), import_node_path83.default.basename(projectPaths.errorsPath))
     );
-    const staleEventsPath = import_node_path81.default.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path81.default.join(import_node_path81.default.dirname(outPath), import_node_path81.default.basename(projectPaths.staleEventsPath))
+    const staleEventsPath = import_node_path83.default.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path83.default.join(import_node_path83.default.dirname(outPath), import_node_path83.default.basename(projectPaths.staleEventsPath))
     );
-    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path81.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path83.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
     const handle = await startWatch(getGraph(project), {
       scanPath,
       outPath,
@@ -25948,7 +26952,7 @@ async function main() {
       project,
       // Resolve NEAT_HOME so a `neat watch` picks up connectors added to
       // ~/.neat/connectors.json (#871). Same resolution the rest of the CLI uses.
-      neatHome: process.env.NEAT_HOME ? import_node_path81.default.resolve(process.env.NEAT_HOME) : import_node_path81.default.join(import_node_os8.default.homedir(), ".neat"),
+      neatHome: process.env.NEAT_HOME ? import_node_path83.default.resolve(process.env.NEAT_HOME) : import_node_path83.default.join(import_node_os8.default.homedir(), ".neat"),
       ...embeddingsCachePath ? { embeddingsCachePath } : {},
       host: process.env.HOST ?? "0.0.0.0",
       port: Number(process.env.PORT ?? 8080),
@@ -26130,11 +27134,11 @@ async function main() {
   process.exit(1);
 }
 async function tryOrchestrator(cmd, parsed) {
-  const scanPath = import_node_path81.default.resolve(cmd);
-  const stat = await import_node_fs46.promises.stat(scanPath).catch(() => null);
+  const scanPath = import_node_path83.default.resolve(cmd);
+  const stat = await import_node_fs48.promises.stat(scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) return null;
   const projectExplicit = parsed.project !== null;
-  const projectName = projectExplicit ? parsed.project : import_node_path81.default.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : import_node_path83.default.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,
@@ -26323,10 +27327,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_types85.DivergenceTypeSchema.safeParse(p);
+          const r = import_types90.DivergenceTypeSchema.safeParse(p);
           if (!r.success) {
             console.error(
-              `neat divergences: unknown --type "${p}". allowed: ${import_types85.DivergenceTypeSchema.options.join(", ")}`
+              `neat divergences: unknown --type "${p}". allowed: ${import_types90.DivergenceTypeSchema.options.join(", ")}`
             );
             return 2;
           }