npm - @neat.is/core - Versions diffs - 0.4.15 → 0.4.16 - Mend

@neat.is/core 0.4.15 → 0.4.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/cli.cjs CHANGED Viewed

@@ -58,9 +58,9 @@ function mountBearerAuth(app, opts) {
   const suffixes = [...DEFAULT_UNAUTH_SUFFIXES, ...opts.extraUnauthenticatedSuffixes ?? []];
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path49 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    const path50 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
     for (const suffix of suffixes) {
-      if (path49 === suffix || path49.endsWith(suffix)) {
+      if (path50 === suffix || path50.endsWith(suffix)) {
         done();
         return;
       }
@@ -188,8 +188,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path39.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path39.default.resolve(here, "..", "proto");
+  const here = import_node_path40.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  return import_node_path40.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -257,13 +257,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path39, import_node_crypto2, grpc, protoLoader;
+var import_node_url2, import_node_path40, import_node_crypto2, grpc, protoLoader;
 var init_otel_grpc = __esm({
   "src/otel-grpc.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_url = require("url");
-    import_node_path39 = __toESM(require("path"), 1);
+    import_node_url2 = require("url");
+    import_node_path40 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
@@ -373,10 +373,10 @@ function parseOtlpRequest(body) {
   return out;
 }
 function loadProtoRoot() {
-  const here = import_node_path40.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path40.default.resolve(here, "..", "proto");
+  const here = import_node_path41.default.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path41.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path40.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path41.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -572,13 +572,13 @@ async function buildOtelReceiver(opts) {
   };
   return decorated;
 }
-var import_node_path40, import_node_url2, import_fastify2, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
+var import_node_path41, import_node_url3, import_fastify2, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path40 = __toESM(require("path"), 1);
-    import_node_url2 = require("url");
+    import_node_path41 = __toESM(require("path"), 1);
+    import_node_url3 = require("url");
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
     init_auth();
@@ -596,18 +596,57 @@ var cli_exports = {};
 __export(cli_exports, {
   CLAUDE_SKILL_CONFIG: () => CLAUDE_SKILL_CONFIG,
   QUERY_VERBS: () => QUERY_VERBS,
+  commandPrefix: () => commandPrefix,
+  isNpxInvocation: () => isNpxInvocation,
+  main: () => main,
   parseArgs: () => parseArgs,
   printBanner: () => printBanner,
   readPackageVersion: () => readPackageVersion,
   runInit: () => runInit,
   runQueryVerb: () => runQueryVerb,
-  runSkill: () => runSkill
+  runSkill: () => runSkill,
+  usage: () => usage
 });
 module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
-var import_node_path48 = __toESM(require("path"), 1);
-var import_node_fs31 = require("fs");
-var import_node_url3 = require("url");
+var import_node_path49 = __toESM(require("path"), 1);
+var import_node_fs32 = require("fs");
+// src/banner.ts
+init_cjs_shims();
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = require("fs");
+var import_node_url = require("url");
+function readPackageVersion() {
+  const here = typeof __dirname !== "undefined" ? __dirname : import_node_path.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  const candidates = [
+    import_node_path.default.resolve(here, "../package.json"),
+    import_node_path.default.resolve(here, "../../package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = (0, import_node_fs.readFileSync)(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.name === "@neat.is/core" && typeof parsed.version === "string") {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  return "unknown";
+}
+function printBanner() {
+  console.log("\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557");
+  console.log("\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D");
+  console.log("\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   ");
+  console.log("\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   ");
+  console.log("\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   ");
+  console.log("\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   ");
+  console.log("");
+  console.log("  Network Expressive Architecting Tool");
+  console.log(`  neat.is  \xB7  v${readPackageVersion()}  \xB7  Apache 2.0`);
+  console.log("");
+}
 // src/graph.ts
 init_cjs_shims();
@@ -642,21 +681,21 @@ init_cjs_shims();
 // src/ingest.ts
 init_cjs_shims();
-var import_node_fs3 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
 var sourceMapJs = __toESM(require("source-map-js"), 1);
 // src/policy.ts
 init_cjs_shims();
-var import_node_fs2 = require("fs");
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
 var import_types2 = require("@neat.is/types");
 // src/compat.ts
 init_cjs_shims();
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_os = __toESM(require("os"), 1);
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_semver = __toESM(require("semver"), 1);
 // compat.json
@@ -785,8 +824,8 @@ var compat_default = {
 var bundledMatrix = compat_default;
 var mergedMatrix = null;
 var remoteLoadAttempted = false;
-var REMOTE_CACHE_DIR = import_node_path.default.join(import_node_os.default.homedir(), ".neat");
-var REMOTE_CACHE_PATH = import_node_path.default.join(REMOTE_CACHE_DIR, "compat-cache.json");
+var REMOTE_CACHE_DIR = import_node_path2.default.join(import_node_os.default.homedir(), ".neat");
+var REMOTE_CACHE_PATH = import_node_path2.default.join(REMOTE_CACHE_DIR, "compat-cache.json");
 var REMOTE_TTL_MS = 24 * 60 * 60 * 1e3;
 function engineMeetsThreshold(engineVersion, threshold) {
   const e = parseInt(engineVersion, 10);
@@ -897,7 +936,7 @@ function mergeMatrices(a, b) {
 }
 async function readRemoteCache(url) {
   try {
-    const raw = await import_node_fs.promises.readFile(REMOTE_CACHE_PATH, "utf8");
+    const raw = await import_node_fs2.promises.readFile(REMOTE_CACHE_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.url !== url) return null;
     const age = Date.now() - new Date(parsed.fetchedAt).getTime();
@@ -914,8 +953,8 @@ async function writeRemoteCache(url, matrix) {
     matrix
   };
   try {
-    await import_node_fs.promises.mkdir(REMOTE_CACHE_DIR, { recursive: true });
-    await import_node_fs.promises.writeFile(REMOTE_CACHE_PATH, JSON.stringify(file), "utf8");
+    await import_node_fs2.promises.mkdir(REMOTE_CACHE_DIR, { recursive: true });
+    await import_node_fs2.promises.writeFile(REMOTE_CACHE_PATH, JSON.stringify(file), "utf8");
   } catch (err) {
     console.warn(`[neat] failed to cache compat matrix: ${err.message}`);
   }
@@ -1136,19 +1175,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, path49, edges) {
-    if (path49.length > best.path.length) {
-      best = { path: [...path49], edges: [...edges] };
+  function step(node, path50, edges) {
+    if (path50.length > best.path.length) {
+      best = { path: [...path50], edges: [...edges] };
     }
-    if (path49.length - 1 >= maxDepth) return;
+    if (path50.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);
-      path49.push(srcId);
+      path50.push(srcId);
       edges.push(edge);
-      step(srcId, path49, edges);
-      path49.pop();
+      step(srcId, path50, edges);
+      path50.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -1607,7 +1646,7 @@ function evaluateAllPolicies(graph, policies, ctx) {
 async function loadPolicyFile(policyPath) {
   let raw;
   try {
-    raw = await import_node_fs2.promises.readFile(policyPath, "utf8");
+    raw = await import_node_fs3.promises.readFile(policyPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -1628,8 +1667,8 @@ var PolicyViolationsLog = class {
     if (!this.seen) await this.hydrate();
     if (this.seen.has(v.id)) return false;
     this.seen.add(v.id);
-    await import_node_fs2.promises.mkdir(import_node_path2.default.dirname(this.path), { recursive: true });
-    await import_node_fs2.promises.appendFile(this.path, JSON.stringify(v) + "\n", "utf8");
+    await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(this.path), { recursive: true });
+    await import_node_fs3.promises.appendFile(this.path, JSON.stringify(v) + "\n", "utf8");
     emitNeatEvent({
       type: "policy-violation",
       project: this.project,
@@ -1639,7 +1678,7 @@ var PolicyViolationsLog = class {
   }
   async readAll() {
     try {
-      const raw = await import_node_fs2.promises.readFile(this.path, "utf8");
+      const raw = await import_node_fs3.promises.readFile(this.path, "utf8");
       return raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -1752,7 +1791,7 @@ function languageForExt(relPath) {
 function relPathForRuntimeFile(filepath, serviceNode, scanPath) {
   let p = toPosix(filepath).replace(/^file:\/\//, "");
   if (scanPath && scanPath.length > 0) {
-    const absRoot = toPosix(import_node_path3.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
+    const absRoot = toPosix(import_node_path4.default.resolve(scanPath, serviceNode?.repoPath ?? ""));
     const anchor = absRoot.endsWith("/") ? absRoot : `${absRoot}/`;
     if (p.startsWith(anchor)) return p.slice(anchor.length);
   }
@@ -1780,10 +1819,10 @@ function resolveDistToSrc(absFilepath, line) {
     entry2 = null;
     const mapPath = `${absFilepath}.map`;
     try {
-      if ((0, import_node_fs3.existsSync)(mapPath)) {
-        const raw = JSON.parse((0, import_node_fs3.readFileSync)(mapPath, "utf8"));
+      if ((0, import_node_fs4.existsSync)(mapPath)) {
+        const raw = JSON.parse((0, import_node_fs4.readFileSync)(mapPath, "utf8"));
         const consumer = new sourceMapJs.SourceMapConsumer(raw);
-        entry2 = { consumer, dir: import_node_path3.default.dirname(mapPath) };
+        entry2 = { consumer, dir: import_node_path4.default.dirname(mapPath) };
       }
     } catch {
       entry2 = null;
@@ -1798,7 +1837,7 @@ function resolveDistToSrc(absFilepath, line) {
     });
     if (!pos || !pos.source) return null;
     const root = entry2.consumer.sourceRoot ?? "";
-    const resolved = import_node_path3.default.resolve(entry2.dir, root, pos.source);
+    const resolved = import_node_path4.default.resolve(entry2.dir, root, pos.source);
     return { filepath: resolved, ...pos.line ? { line: pos.line } : {} };
   } catch {
     return null;
@@ -2065,8 +2104,8 @@ function upsertInferredEdge(graph, type, source, target, ts) {
   graph.addEdgeWithKey(id, source, target, edge);
 }
 async function appendErrorEvent(ctx, ev) {
-  await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(ctx.errorsPath), { recursive: true });
-  await import_node_fs3.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
+  await import_node_fs4.promises.mkdir(import_node_path4.default.dirname(ctx.errorsPath), { recursive: true });
+  await import_node_fs4.promises.appendFile(ctx.errorsPath, JSON.stringify(ev) + "\n", "utf8");
 }
 function sanitizeAttributes(attrs) {
   const out = {};
@@ -2097,8 +2136,8 @@ function makeErrorSpanWriter(errorsPath) {
   return async (span) => {
     const ev = buildErrorEventForReceiver(span);
     if (!ev) return;
-    await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(errorsPath), { recursive: true });
-    await import_node_fs3.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
+    await import_node_fs4.promises.mkdir(import_node_path4.default.dirname(errorsPath), { recursive: true });
+    await import_node_fs4.promises.appendFile(errorsPath, JSON.stringify(ev) + "\n", "utf8");
   };
 }
 async function handleSpan(ctx, span) {
@@ -2317,13 +2356,13 @@ async function markStaleEdges(graph, options = {}) {
   return { count: events.length, events };
 }
 async function appendStaleEvents(staleEventsPath, events) {
-  await import_node_fs3.promises.mkdir(import_node_path3.default.dirname(staleEventsPath), { recursive: true });
+  await import_node_fs4.promises.mkdir(import_node_path4.default.dirname(staleEventsPath), { recursive: true });
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await import_node_fs3.promises.appendFile(staleEventsPath, lines, "utf8");
+  await import_node_fs4.promises.appendFile(staleEventsPath, lines, "utf8");
 }
 async function readStaleEvents(staleEventsPath) {
   try {
-    const raw = await import_node_fs3.promises.readFile(staleEventsPath, "utf8");
+    const raw = await import_node_fs4.promises.readFile(staleEventsPath, "utf8");
     return raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -2357,7 +2396,7 @@ function startStalenessLoop(graph, options = {}) {
 }
 async function readErrorEvents(errorsPath) {
   try {
-    const raw = await import_node_fs3.promises.readFile(errorsPath, "utf8");
+    const raw = await import_node_fs4.promises.readFile(errorsPath, "utf8");
     return raw.split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -2389,16 +2428,16 @@ function mergeSnapshot(graph, snapshot) {
 // src/extract/services.ts
 init_cjs_shims();
-var import_node_fs8 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
 var import_ignore = __toESM(require("ignore"), 1);
 var import_minimatch2 = require("minimatch");
 var import_types5 = require("@neat.is/types");
 // src/extract/shared.ts
 init_cjs_shims();
-var import_node_fs4 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_fs5 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
 var import_yaml = require("yaml");
 var import_types4 = require("@neat.is/types");
 var SERVICE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".py"]);
@@ -2430,7 +2469,7 @@ async function isPythonVenvDir(dir) {
   const cached = PYVENV_MARKER_CACHE.get(dir);
   if (cached !== void 0) return cached;
   try {
-    const stat = await import_node_fs4.promises.stat(import_node_path4.default.join(dir, "pyvenv.cfg"));
+    const stat = await import_node_fs5.promises.stat(import_node_path5.default.join(dir, "pyvenv.cfg"));
     const ok = stat.isFile();
     PYVENV_MARKER_CACHE.set(dir, ok);
     return ok;
@@ -2440,7 +2479,7 @@ async function isPythonVenvDir(dir) {
   }
 }
 function isConfigFile(name) {
-  const ext = import_node_path4.default.extname(name);
+  const ext = import_node_path5.default.extname(name);
   if (CONFIG_FILE_EXTENSIONS.has(ext)) return { match: true, fileType: ext.slice(1) };
   if (name === ".env" || name.startsWith(".env.")) {
     if (isEnvTemplateFile(name)) return { match: false, fileType: "" };
@@ -2548,16 +2587,16 @@ function cleanVersion(raw) {
   return raw.replace(/^[\^~><=v\s]+/, "").trim() || void 0;
 }
 async function readJson(filePath) {
-  const raw = await import_node_fs4.promises.readFile(filePath, "utf8");
+  const raw = await import_node_fs5.promises.readFile(filePath, "utf8");
   return JSON.parse(raw);
 }
 async function readYaml(filePath) {
-  const raw = await import_node_fs4.promises.readFile(filePath, "utf8");
+  const raw = await import_node_fs5.promises.readFile(filePath, "utf8");
   return (0, import_yaml.parse)(raw);
 }
 async function exists(p) {
   try {
-    await import_node_fs4.promises.access(p);
+    await import_node_fs5.promises.access(p);
     return true;
   } catch {
     return false;
@@ -2566,8 +2605,8 @@ async function exists(p) {
 // src/extract/python.ts
 init_cjs_shims();
-var import_node_fs5 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs6 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
 var import_smol_toml = require("smol-toml");
 var REQUIREMENT_LINE = /^\s*([A-Za-z0-9_.-]+)(?:\[[^\]]*\])?\s*(?:(==)\s*([A-Za-z0-9_.+-]+))?/;
 function parseRequirementsTxt(content) {
@@ -2600,25 +2639,25 @@ function depsFromPyProject(pyproject) {
   return out;
 }
 async function discoverPythonService(serviceDir) {
-  const pyprojectPath = import_node_path5.default.join(serviceDir, "pyproject.toml");
-  const requirementsPath = import_node_path5.default.join(serviceDir, "requirements.txt");
-  const setupPath = import_node_path5.default.join(serviceDir, "setup.py");
+  const pyprojectPath = import_node_path6.default.join(serviceDir, "pyproject.toml");
+  const requirementsPath = import_node_path6.default.join(serviceDir, "requirements.txt");
+  const setupPath = import_node_path6.default.join(serviceDir, "setup.py");
   const hasPyproject = await exists(pyprojectPath);
   const hasRequirements = await exists(requirementsPath);
   const hasSetup = await exists(setupPath);
   if (!hasPyproject && !hasRequirements && !hasSetup) return null;
-  let name = import_node_path5.default.basename(serviceDir);
+  let name = import_node_path6.default.basename(serviceDir);
   let version;
   const dependencies = {};
   if (hasPyproject) {
-    const raw = await import_node_fs5.promises.readFile(pyprojectPath, "utf8");
+    const raw = await import_node_fs6.promises.readFile(pyprojectPath, "utf8");
     const pyproject = (0, import_smol_toml.parse)(raw);
     name = pyproject.project?.name ?? pyproject.tool?.poetry?.name ?? name;
     version = pyproject.project?.version ?? pyproject.tool?.poetry?.version ?? void 0;
     Object.assign(dependencies, depsFromPyProject(pyproject));
   }
   if (hasRequirements) {
-    const raw = await import_node_fs5.promises.readFile(requirementsPath, "utf8");
+    const raw = await import_node_fs6.promises.readFile(requirementsPath, "utf8");
     Object.assign(dependencies, parseRequirementsTxt(raw));
   }
   return { name, version, dependencies };
@@ -2633,17 +2672,17 @@ function pythonToPackage(service) {
 // src/extract/owners.ts
 init_cjs_shims();
-var import_node_fs6 = require("fs");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+var import_node_path7 = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
 async function loadCodeowners(scanPath) {
   const candidates = [
-    import_node_path6.default.join(scanPath, "CODEOWNERS"),
-    import_node_path6.default.join(scanPath, ".github", "CODEOWNERS")
+    import_node_path7.default.join(scanPath, "CODEOWNERS"),
+    import_node_path7.default.join(scanPath, ".github", "CODEOWNERS")
   ];
   for (const file of candidates) {
     if (await exists(file)) {
-      const raw = await import_node_fs6.promises.readFile(file, "utf8");
+      const raw = await import_node_fs7.promises.readFile(file, "utf8");
       return parseCodeowners(raw);
     }
   }
@@ -2661,7 +2700,7 @@ function parseCodeowners(raw) {
   return { rules };
 }
 function matchOwner(file, repoPath) {
-  const normalized = repoPath.split(import_node_path6.default.sep).join("/");
+  const normalized = repoPath.split(import_node_path7.default.sep).join("/");
   for (const rule of file.rules) {
     if (matchesPattern(rule.pattern, normalized)) return rule.owners;
   }
@@ -2677,7 +2716,7 @@ function matchesPattern(rawPattern, repoPath) {
   return false;
 }
 async function readPackageJsonAuthor(serviceDir) {
-  const pkgPath = import_node_path6.default.join(serviceDir, "package.json");
+  const pkgPath = import_node_path7.default.join(serviceDir, "package.json");
   if (!await exists(pkgPath)) return null;
   try {
     const pkg = await readJson(pkgPath);
@@ -2700,8 +2739,8 @@ async function computeServiceOwner(codeowners, repoPath, serviceDir) {
 // src/extract/errors.ts
 init_cjs_shims();
-var import_node_fs7 = require("fs");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path8 = __toESM(require("path"), 1);
 var sink = [];
 function recordExtractionError(producer, file, err) {
   const e = err instanceof Error ? err : new Error(String(err));
@@ -2720,9 +2759,9 @@ function drainExtractionErrors() {
 }
 async function writeExtractionErrors(errors, errorsPath) {
   if (errors.length === 0) return;
-  await import_node_fs7.promises.mkdir(import_node_path7.default.dirname(errorsPath), { recursive: true });
+  await import_node_fs8.promises.mkdir(import_node_path8.default.dirname(errorsPath), { recursive: true });
   const lines = errors.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await import_node_fs7.promises.appendFile(errorsPath, lines, "utf8");
+  await import_node_fs8.promises.appendFile(errorsPath, lines, "utf8");
 }
 function isStrictExtractionEnabled() {
   const raw = process.env.NEAT_STRICT_EXTRACTION;
@@ -2745,9 +2784,9 @@ function isRejectedLogEnabled() {
 }
 async function writeRejectedExtracted(drops, rejectedPath) {
   if (drops.length === 0) return;
-  await import_node_fs7.promises.mkdir(import_node_path7.default.dirname(rejectedPath), { recursive: true });
+  await import_node_fs8.promises.mkdir(import_node_path8.default.dirname(rejectedPath), { recursive: true });
   const lines = drops.map((d) => JSON.stringify({ ...d, ts: (/* @__PURE__ */ new Date()).toISOString() })).join("\n") + "\n";
-  await import_node_fs7.promises.appendFile(rejectedPath, lines, "utf8");
+  await import_node_fs8.promises.appendFile(rejectedPath, lines, "utf8");
 }
 function formatPrecisionFloorBanner(count) {
   if (count === 1) return `[neat] 1 extracted edge dropped below precision floor`;
@@ -2770,21 +2809,21 @@ function workspaceGlobs(pkg) {
   return null;
 }
 async function loadGitignore(scanPath) {
-  const gitignorePath = import_node_path8.default.join(scanPath, ".gitignore");
+  const gitignorePath = import_node_path9.default.join(scanPath, ".gitignore");
   if (!await exists(gitignorePath)) return null;
-  const raw = await import_node_fs8.promises.readFile(gitignorePath, "utf8");
+  const raw = await import_node_fs9.promises.readFile(gitignorePath, "utf8");
   return (0, import_ignore.default)().add(raw);
 }
 async function walkDirs(start, scanPath, options, visit) {
   async function recurse(current, depth) {
     if (depth > options.maxDepth) return;
-    const entries = await import_node_fs8.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs9.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry2 of entries) {
       if (!entry2.isDirectory()) continue;
       if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path8.default.join(current, entry2.name);
+      const child = import_node_path9.default.join(current, entry2.name);
       if (options.ig) {
-        const rel = import_node_path8.default.relative(scanPath, child).split(import_node_path8.default.sep).join("/");
+        const rel = import_node_path9.default.relative(scanPath, child).split(import_node_path9.default.sep).join("/");
         if (rel && options.ig.ignores(rel + "/")) continue;
       }
       if (await isPythonVenvDir(child)) continue;
@@ -2800,8 +2839,8 @@ async function expandWorkspaceGlobs(scanPath, globs) {
   for (const raw of globs) {
     const pattern = raw.replace(/^\.\//, "");
     if (!pattern.includes("*")) {
-      const candidate = import_node_path8.default.join(scanPath, pattern);
-      if (await exists(import_node_path8.default.join(candidate, "package.json"))) found.add(candidate);
+      const candidate = import_node_path9.default.join(scanPath, pattern);
+      if (await exists(import_node_path9.default.join(candidate, "package.json"))) found.add(candidate);
       continue;
     }
     const segments = pattern.split("/");
@@ -2810,13 +2849,13 @@ async function expandWorkspaceGlobs(scanPath, globs) {
       if (seg.includes("*")) break;
       staticSegments.push(seg);
     }
-    const start = import_node_path8.default.join(scanPath, ...staticSegments);
+    const start = import_node_path9.default.join(scanPath, ...staticSegments);
     if (!await exists(start)) continue;
     const hasDoubleStar = pattern.includes("**");
     const walkDepth = hasDoubleStar ? scanDepth : Math.max(0, segments.length - staticSegments.length - 1);
     await walkDirs(start, scanPath, { maxDepth: walkDepth, ig: null }, async (dir) => {
-      const rel = import_node_path8.default.relative(scanPath, dir).split(import_node_path8.default.sep).join("/");
-      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists(import_node_path8.default.join(dir, "package.json"))) {
+      const rel = import_node_path9.default.relative(scanPath, dir).split(import_node_path9.default.sep).join("/");
+      if ((0, import_minimatch2.minimatch)(rel, pattern) && await exists(import_node_path9.default.join(dir, "package.json"))) {
         found.add(dir);
       }
     });
@@ -2836,13 +2875,13 @@ function detectJsFramework(pkg) {
   return void 0;
 }
 async function discoverNodeService(scanPath, dir) {
-  const pkgPath = import_node_path8.default.join(dir, "package.json");
+  const pkgPath = import_node_path9.default.join(dir, "package.json");
   if (!await exists(pkgPath)) return null;
   let pkg;
   try {
     pkg = await readJson(pkgPath);
   } catch (err) {
-    recordExtractionError("services", import_node_path8.default.relative(scanPath, pkgPath), err);
+    recordExtractionError("services", import_node_path9.default.relative(scanPath, pkgPath), err);
     return null;
   }
   if (!pkg.name) return null;
@@ -2854,7 +2893,7 @@ async function discoverNodeService(scanPath, dir) {
     language: "javascript",
     version: pkg.version,
     dependencies: pkg.dependencies ?? {},
-    repoPath: import_node_path8.default.relative(scanPath, dir),
+    repoPath: import_node_path9.default.relative(scanPath, dir),
     ...pkg.engines?.node ? { nodeEngine: pkg.engines.node } : {},
     ...framework ? { framework } : {}
   };
@@ -2871,12 +2910,12 @@ async function discoverPyService(scanPath, dir) {
     language: "python",
     version: py.version,
     dependencies: py.dependencies,
-    repoPath: import_node_path8.default.relative(scanPath, dir)
+    repoPath: import_node_path9.default.relative(scanPath, dir)
   };
   return { pkg, dir, node };
 }
 async function discoverServices(scanPath) {
-  const rootPkgPath = import_node_path8.default.join(scanPath, "package.json");
+  const rootPkgPath = import_node_path9.default.join(scanPath, "package.json");
   let rootPkg = null;
   if (await exists(rootPkgPath)) {
     try {
@@ -2884,7 +2923,7 @@ async function discoverServices(scanPath) {
     } catch (err) {
       recordExtractionError(
         "services workspaces",
-        import_node_path8.default.relative(scanPath, rootPkgPath),
+        import_node_path9.default.relative(scanPath, rootPkgPath),
         err
       );
     }
@@ -2901,9 +2940,9 @@ async function discoverServices(scanPath) {
       scanPath,
       { maxDepth: parseScanDepth(), ig },
       async (dir) => {
-        if (await exists(import_node_path8.default.join(dir, "package.json"))) {
+        if (await exists(import_node_path9.default.join(dir, "package.json"))) {
           candidateDirs.push(dir);
-        } else if (await exists(import_node_path8.default.join(dir, "pyproject.toml")) || await exists(import_node_path8.default.join(dir, "requirements.txt")) || await exists(import_node_path8.default.join(dir, "setup.py"))) {
+        } else if (await exists(import_node_path9.default.join(dir, "pyproject.toml")) || await exists(import_node_path9.default.join(dir, "requirements.txt")) || await exists(import_node_path9.default.join(dir, "setup.py"))) {
           candidateDirs.push(dir);
         }
       }
@@ -2917,8 +2956,8 @@ async function discoverServices(scanPath) {
     if (!service) continue;
     const existingDir = seen.get(service.node.name);
     if (existingDir !== void 0) {
-      const a = import_node_path8.default.relative(scanPath, existingDir) || ".";
-      const b = import_node_path8.default.relative(scanPath, dir) || ".";
+      const a = import_node_path9.default.relative(scanPath, existingDir) || ".";
+      const b = import_node_path9.default.relative(scanPath, dir) || ".";
       console.warn(
         `[neat] duplicate package name "${service.node.name}" \u2014 keeping ${a}, ignoring ${b}`
       );
@@ -2955,8 +2994,8 @@ function addServiceNodes(graph, services) {
 // src/extract/aliases.ts
 init_cjs_shims();
-var import_node_path9 = __toESM(require("path"), 1);
-var import_node_fs9 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
 var import_yaml2 = require("yaml");
 var import_types6 = require("@neat.is/types");
 var K8S_KINDS_WITH_HOSTNAMES = /* @__PURE__ */ new Set([
@@ -2983,14 +3022,14 @@ function indexServicesByName(services) {
   const map = /* @__PURE__ */ new Map();
   for (const s of services) {
     map.set(s.node.name, s.node.id);
-    map.set(import_node_path9.default.basename(s.dir), s.node.id);
+    map.set(import_node_path10.default.basename(s.dir), s.node.id);
   }
   return map;
 }
 async function collectComposeAliases(graph, scanPath, serviceIndex) {
   let composePath = null;
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path9.default.join(scanPath, name);
+    const abs = import_node_path10.default.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -3003,7 +3042,7 @@ async function collectComposeAliases(graph, scanPath, serviceIndex) {
   } catch (err) {
     recordExtractionError(
       "aliases compose",
-      import_node_path9.default.relative(scanPath, composePath),
+      import_node_path10.default.relative(scanPath, composePath),
       err
     );
     return;
@@ -3046,11 +3085,11 @@ function parseDockerfileLabels(content) {
 }
 async function collectDockerfileAliases(graph, services) {
   for (const service of services) {
-    const dockerfilePath = import_node_path9.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path10.default.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs9.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs10.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError("aliases dockerfile", dockerfilePath, err);
       continue;
@@ -3062,15 +3101,15 @@ async function collectDockerfileAliases(graph, services) {
 async function walkYamlFiles(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await import_node_fs9.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs10.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry2 of entries) {
     if (entry2.isDirectory()) {
       if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path9.default.join(start, entry2.name);
+      const child = import_node_path10.default.join(start, entry2.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles(child, depth + 1, max));
-    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path9.default.extname(entry2.name))) {
-      out.push(import_node_path9.default.join(start, entry2.name));
+    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path10.default.extname(entry2.name))) {
+      out.push(import_node_path10.default.join(start, entry2.name));
     }
   }
   return out;
@@ -3097,7 +3136,7 @@ function k8sServiceTarget(doc, byName) {
 async function collectK8sAliases(graph, scanPath, serviceIndex) {
   const files = await walkYamlFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs9.promises.readFile(file, "utf8");
+    const content = await import_node_fs10.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml2.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -3125,20 +3164,20 @@ init_cjs_shims();
 // src/extract/calls/shared.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_node_path11 = __toESM(require("path"), 1);
 var import_types7 = require("@neat.is/types");
 async function walkSourceFiles(dir) {
   const out = [];
   async function walk(current) {
-    const entries = await import_node_fs10.promises.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_node_fs11.promises.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry2 of entries) {
-      const full = import_node_path10.default.join(current, entry2.name);
+      const full = import_node_path11.default.join(current, entry2.name);
       if (entry2.isDirectory()) {
         if (IGNORED_DIRS.has(entry2.name)) continue;
         if (await isPythonVenvDir(full)) continue;
         await walk(full);
-      } else if (entry2.isFile() && SERVICE_FILE_EXTENSIONS.has(import_node_path10.default.extname(entry2.name))) {
+      } else if (entry2.isFile() && SERVICE_FILE_EXTENSIONS.has(import_node_path11.default.extname(entry2.name))) {
         out.push(full);
       }
     }
@@ -3151,7 +3190,7 @@ async function loadSourceFiles(dir) {
   const out = [];
   for (const p of paths) {
     try {
-      const content = await import_node_fs10.promises.readFile(p, "utf8");
+      const content = await import_node_fs11.promises.readFile(p, "utf8");
       out.push({ path: p, content });
     } catch {
     }
@@ -3171,7 +3210,7 @@ function toPosix2(p) {
   return p.split("\\").join("/");
 }
 function languageForPath(relPath) {
-  switch (import_node_path10.default.extname(relPath).toLowerCase()) {
+  switch (import_node_path11.default.extname(relPath).toLowerCase()) {
     case ".py":
       return "python";
     case ".ts":
@@ -3221,14 +3260,14 @@ function ensureFileNode(graph, serviceName, serviceNodeId, relPath) {
 }
 // src/extract/files.ts
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 async function addFiles(graph, services) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
     const filePaths = await walkSourceFiles(service.dir);
     for (const filePath of filePaths) {
-      const relPath = toPosix2(import_node_path11.default.relative(service.dir, filePath));
+      const relPath = toPosix2(import_node_path12.default.relative(service.dir, filePath));
       const { nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -3244,8 +3283,8 @@ async function addFiles(graph, services) {
 // src/extract/imports.ts
 init_cjs_shims();
-var import_node_path12 = __toESM(require("path"), 1);
-var import_node_fs11 = require("fs");
+var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
 var import_tree_sitter = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python = __toESM(require("tree-sitter-python"), 1);
@@ -3349,15 +3388,15 @@ function collectPyImports(node, out) {
 }
 async function fileExists(p) {
   try {
-    await import_node_fs11.promises.access(p);
+    await import_node_fs12.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 function isWithinServiceDir(candidate, serviceDir) {
-  const rel = import_node_path12.default.relative(serviceDir, candidate);
-  return rel !== "" && !rel.startsWith("..") && !import_node_path12.default.isAbsolute(rel);
+  const rel = import_node_path13.default.relative(serviceDir, candidate);
+  return rel !== "" && !rel.startsWith("..") && !import_node_path13.default.isAbsolute(rel);
 }
 var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 var JS_INDEX_FILES = JS_EXTENSIONS.map((ext) => `index${ext}`);
@@ -3365,22 +3404,22 @@ async function firstExistingCandidate(base, serviceDir) {
   for (const ext of JS_EXTENSIONS) {
     const candidate = base + ext;
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix2(import_node_path12.default.relative(serviceDir, candidate));
+      return toPosix2(import_node_path13.default.relative(serviceDir, candidate));
     }
   }
   for (const indexFile of JS_INDEX_FILES) {
-    const candidate = import_node_path12.default.join(base, indexFile);
+    const candidate = import_node_path13.default.join(base, indexFile);
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix2(import_node_path12.default.relative(serviceDir, candidate));
+      return toPosix2(import_node_path13.default.relative(serviceDir, candidate));
     }
   }
   return null;
 }
 async function loadTsPathConfig(serviceDir) {
-  const tsconfigPath = import_node_path12.default.join(serviceDir, "tsconfig.json");
+  const tsconfigPath = import_node_path13.default.join(serviceDir, "tsconfig.json");
   let raw;
   try {
-    raw = await import_node_fs11.promises.readFile(tsconfigPath, "utf8");
+    raw = await import_node_fs12.promises.readFile(tsconfigPath, "utf8");
   } catch {
     return null;
   }
@@ -3389,7 +3428,7 @@ async function loadTsPathConfig(serviceDir) {
     const paths = parsed.compilerOptions?.paths;
     if (!paths || Object.keys(paths).length === 0) return null;
     const baseUrl = parsed.compilerOptions?.baseUrl;
-    return { paths, baseDir: baseUrl ? import_node_path12.default.resolve(serviceDir, baseUrl) : serviceDir };
+    return { paths, baseDir: baseUrl ? import_node_path13.default.resolve(serviceDir, baseUrl) : serviceDir };
   } catch (err) {
     recordExtractionError("import alias resolution", tsconfigPath, err);
     return null;
@@ -3407,11 +3446,11 @@ async function resolveTsAlias(specifier, config, serviceDir) {
     if (suffix === null) continue;
     for (const target of targets) {
       const targetBase = target.endsWith("/*") ? target.slice(0, -2) : target.replace(/\*$/, "");
-      const resolvedBase = import_node_path12.default.resolve(config.baseDir, targetBase, suffix);
+      const resolvedBase = import_node_path13.default.resolve(config.baseDir, targetBase, suffix);
       const hit = await firstExistingCandidate(resolvedBase, serviceDir);
       if (hit) return hit;
       if (isWithinServiceDir(resolvedBase, serviceDir) && await fileExists(resolvedBase)) {
-        return toPosix2(import_node_path12.default.relative(serviceDir, resolvedBase));
+        return toPosix2(import_node_path13.default.relative(serviceDir, resolvedBase));
       }
     }
   }
@@ -3420,18 +3459,18 @@ async function resolveTsAlias(specifier, config, serviceDir) {
 async function resolveJsImport(specifier, importerDir, serviceDir, tsPaths) {
   if (!specifier) return null;
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const base = import_node_path12.default.resolve(importerDir, specifier);
-    const ext = import_node_path12.default.extname(specifier);
+    const base = import_node_path13.default.resolve(importerDir, specifier);
+    const ext = import_node_path13.default.extname(specifier);
     if (ext) {
       if (ext === ".js" || ext === ".jsx") {
         const tsExt = ext === ".jsx" ? ".tsx" : ".ts";
         const tsSibling = base.slice(0, -ext.length) + tsExt;
         if (isWithinServiceDir(tsSibling, serviceDir) && await fileExists(tsSibling)) {
-          return toPosix2(import_node_path12.default.relative(serviceDir, tsSibling));
+          return toPosix2(import_node_path13.default.relative(serviceDir, tsSibling));
         }
       }
       if (isWithinServiceDir(base, serviceDir) && await fileExists(base)) {
-        return toPosix2(import_node_path12.default.relative(serviceDir, base));
+        return toPosix2(import_node_path13.default.relative(serviceDir, base));
       }
       return null;
     }
@@ -3445,15 +3484,15 @@ async function resolvePyImport(imp, importerPath, serviceDir) {
   const relPath = imp.modulePath.split(".").join("/");
   let baseDir;
   if (imp.level > 0) {
-    baseDir = import_node_path12.default.dirname(importerPath);
-    for (let i = 1; i < imp.level; i++) baseDir = import_node_path12.default.dirname(baseDir);
+    baseDir = import_node_path13.default.dirname(importerPath);
+    for (let i = 1; i < imp.level; i++) baseDir = import_node_path13.default.dirname(baseDir);
   } else {
     baseDir = serviceDir;
   }
-  const candidates = [import_node_path12.default.join(baseDir, `${relPath}.py`), import_node_path12.default.join(baseDir, relPath, "__init__.py")];
+  const candidates = [import_node_path13.default.join(baseDir, `${relPath}.py`), import_node_path13.default.join(baseDir, relPath, "__init__.py")];
   for (const candidate of candidates) {
     if (isWithinServiceDir(candidate, serviceDir) && await fileExists(candidate)) {
-      return toPosix2(import_node_path12.default.relative(serviceDir, candidate));
+      return toPosix2(import_node_path13.default.relative(serviceDir, candidate));
     }
   }
   return null;
@@ -3484,9 +3523,9 @@ async function addImports(graph, services) {
     const files = await loadSourceFiles(service.dir);
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const relFile = toPosix2(import_node_path12.default.relative(service.dir, file.path));
+      const relFile = toPosix2(import_node_path13.default.relative(service.dir, file.path));
       const importerFileId = (0, import_types8.fileId)(service.pkg.name, relFile);
-      const isPython = import_node_path12.default.extname(file.path) === ".py";
+      const isPython = import_node_path13.default.extname(file.path) === ".py";
       if (isPython) {
         let pyImports = [];
         try {
@@ -3520,7 +3559,7 @@ async function addImports(graph, services) {
         continue;
       }
       for (const imp of jsImports) {
-        const resolved = await resolveJsImport(imp.specifier, import_node_path12.default.dirname(file.path), service.dir, tsPaths);
+        const resolved = await resolveJsImport(imp.specifier, import_node_path13.default.dirname(file.path), service.dir, tsPaths);
         if (!resolved) continue;
         edgesAdded += emitImportEdge(
           graph,
@@ -3539,14 +3578,14 @@ async function addImports(graph, services) {
 // src/extract/databases/index.ts
 init_cjs_shims();
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 var import_types9 = require("@neat.is/types");
 // src/extract/databases/db-config-yaml.ts
 init_cjs_shims();
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 async function parse(serviceDir) {
-  const yamlPath = import_node_path13.default.join(serviceDir, "db-config.yaml");
+  const yamlPath = import_node_path14.default.join(serviceDir, "db-config.yaml");
   if (!await exists(yamlPath)) return [];
   const raw = await readYaml(yamlPath);
   return [
@@ -3564,13 +3603,13 @@ var dbConfigYamlParser = { name: "db-config.yaml", parse };
 // src/extract/databases/dotenv.ts
 init_cjs_shims();
-var import_node_fs13 = require("fs");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs14 = require("fs");
+var import_node_path16 = __toESM(require("path"), 1);
 // src/extract/databases/shared.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
 function schemeToEngine(scheme) {
   const s = scheme.toLowerCase().split("+")[0];
   switch (s) {
@@ -3609,14 +3648,14 @@ function parseConnectionString(url) {
 }
 async function readIfExists(filePath) {
   try {
-    return await import_node_fs12.promises.readFile(filePath, "utf8");
+    return await import_node_fs13.promises.readFile(filePath, "utf8");
   } catch {
     return null;
   }
 }
 async function findFirst(serviceDir, candidates) {
   for (const rel of candidates) {
-    const abs = import_node_path14.default.join(serviceDir, rel);
+    const abs = import_node_path15.default.join(serviceDir, rel);
     const content = await readIfExists(abs);
     if (content !== null) return abs;
   }
@@ -3667,15 +3706,15 @@ function parseDotenvLine(line) {
   return { key, value };
 }
 async function parse2(serviceDir) {
-  const entries = await import_node_fs13.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs14.promises.readdir(serviceDir, { withFileTypes: true }).catch(() => []);
   const configs = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry2 of entries) {
     if (!entry2.isFile()) continue;
     const match = isConfigFile(entry2.name);
     if (!match.match || match.fileType !== "env") continue;
-    const filePath = import_node_path15.default.join(serviceDir, entry2.name);
-    const content = await import_node_fs13.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path16.default.join(serviceDir, entry2.name);
+    const content = await import_node_fs14.promises.readFile(filePath, "utf8");
     for (const line of content.split("\n")) {
       const parsed = parseDotenvLine(line);
       if (!parsed) continue;
@@ -3694,9 +3733,9 @@ var dotenvParser = { name: ".env", parse: parse2 };
 // src/extract/databases/prisma.ts
 init_cjs_shims();
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 async function parse3(serviceDir) {
-  const schemaPath = import_node_path16.default.join(serviceDir, "prisma", "schema.prisma");
+  const schemaPath = import_node_path17.default.join(serviceDir, "prisma", "schema.prisma");
   const content = await readIfExists(schemaPath);
   if (!content) return [];
   const block = content.match(/datasource\s+\w+\s*\{([^}]*)\}/s);
@@ -3828,10 +3867,10 @@ var knexParser = { name: "knex", parse: parse5 };
 // src/extract/databases/ormconfig.ts
 init_cjs_shims();
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 async function parse6(serviceDir) {
   for (const candidate of ["ormconfig.json", "ormconfig.yaml", "ormconfig.yml"]) {
-    const abs = import_node_path17.default.join(serviceDir, candidate);
+    const abs = import_node_path18.default.join(serviceDir, candidate);
     if (!await exists(abs)) continue;
     const raw = candidate.endsWith(".json") ? await readJson(abs) : await readYaml(abs);
     const entries = Array.isArray(raw) ? raw : [raw];
@@ -3891,9 +3930,9 @@ var typeormParser = { name: "typeorm", parse: parse7 };
 // src/extract/databases/sequelize.ts
 init_cjs_shims();
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 async function parse8(serviceDir) {
-  const configPath = import_node_path18.default.join(serviceDir, "config", "config.json");
+  const configPath = import_node_path19.default.join(serviceDir, "config", "config.json");
   if (!await exists(configPath)) return [];
   const raw = await readJson(configPath);
   const out = [];
@@ -3920,7 +3959,7 @@ var sequelizeParser = { name: "sequelize", parse: parse8 };
 // src/extract/databases/docker-compose.ts
 init_cjs_shims();
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 function portFromService(svc) {
   for (const raw of svc.ports ?? []) {
     const str = String(raw);
@@ -3947,7 +3986,7 @@ function databaseFromEnv(svc) {
 }
 async function parse9(serviceDir) {
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path19.default.join(serviceDir, name);
+    const abs = import_node_path20.default.join(serviceDir, name);
     if (!await exists(abs)) continue;
     const raw = await readYaml(abs);
     if (!raw?.services) return [];
@@ -4119,7 +4158,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
           discoveredVia: mergedDiscoveredVia
         });
       }
-      const relConfigFile = toPosix2(import_node_path20.default.relative(service.dir, config.sourceFile));
+      const relConfigFile = toPosix2(import_node_path21.default.relative(service.dir, config.sourceFile));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -4128,7 +4167,7 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
       );
       nodesAdded += fn;
       edgesAdded += fe;
-      const evidenceFile = toPosix2(import_node_path20.default.relative(scanPath, config.sourceFile));
+      const evidenceFile = toPosix2(import_node_path21.default.relative(scanPath, config.sourceFile));
       const edge = {
         id: (0, import_types4.extractedEdgeId)(fileNodeId, dbNode.id, import_types9.EdgeType.CONNECTS_TO),
         source: fileNodeId,
@@ -4162,15 +4201,15 @@ async function addDatabasesAndCompat(graph, services, scanPath) {
 // src/extract/configs.ts
 init_cjs_shims();
-var import_node_fs14 = require("fs");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_node_path22 = __toESM(require("path"), 1);
 var import_types10 = require("@neat.is/types");
 async function walkConfigFiles(dir) {
   const out = [];
   async function walk(current) {
-    const entries = await import_node_fs14.promises.readdir(current, { withFileTypes: true });
+    const entries = await import_node_fs15.promises.readdir(current, { withFileTypes: true });
     for (const entry2 of entries) {
-      const full = import_node_path21.default.join(current, entry2.name);
+      const full = import_node_path22.default.join(current, entry2.name);
       if (entry2.isDirectory()) {
         if (IGNORED_DIRS.has(entry2.name)) continue;
         if (await isPythonVenvDir(full)) continue;
@@ -4189,19 +4228,19 @@ async function addConfigNodes(graph, services, scanPath) {
   for (const service of services) {
     const configFiles = await walkConfigFiles(service.dir);
     for (const file of configFiles) {
-      const relPath = import_node_path21.default.relative(scanPath, file);
+      const relPath = import_node_path22.default.relative(scanPath, file);
       const node = {
         id: (0, import_types10.configId)(relPath),
         type: import_types10.NodeType.ConfigNode,
-        name: import_node_path21.default.basename(file),
+        name: import_node_path22.default.basename(file),
         path: relPath,
-        fileType: isConfigFile(import_node_path21.default.basename(file)).fileType
+        fileType: isConfigFile(import_node_path22.default.basename(file)).fileType
       };
       if (!graph.hasNode(node.id)) {
         graph.addNode(node.id, node);
         nodesAdded++;
       }
-      const relToService = toPosix2(import_node_path21.default.relative(service.dir, file));
+      const relToService = toPosix2(import_node_path22.default.relative(service.dir, file));
       const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
         graph,
         service.pkg.name,
@@ -4217,7 +4256,7 @@ async function addConfigNodes(graph, services, scanPath) {
         type: import_types10.EdgeType.CONFIGURED_BY,
         provenance: import_types10.Provenance.EXTRACTED,
         confidence: (0, import_types10.confidenceForExtracted)("structural"),
-        evidence: { file: relPath.split(import_node_path21.default.sep).join("/") }
+        evidence: { file: relPath.split(import_node_path22.default.sep).join("/") }
       };
       if (!graph.hasEdge(edge.id)) {
         graph.addEdgeWithKey(edge.id, edge.source, edge.target, edge);
@@ -4234,7 +4273,7 @@ var import_types16 = require("@neat.is/types");
 // src/extract/calls/http.ts
 init_cjs_shims();
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 var import_tree_sitter2 = __toESM(require("tree-sitter"), 1);
 var import_tree_sitter_javascript2 = __toESM(require("tree-sitter-javascript"), 1);
 var import_tree_sitter_python2 = __toESM(require("tree-sitter-python"), 1);
@@ -4303,9 +4342,9 @@ async function addHttpCallEdges(graph, services) {
   const knownHosts = /* @__PURE__ */ new Set();
   const hostToNodeId = /* @__PURE__ */ new Map();
   for (const service of services) {
-    knownHosts.add(import_node_path22.default.basename(service.dir));
+    knownHosts.add(import_node_path23.default.basename(service.dir));
     knownHosts.add(service.pkg.name);
-    hostToNodeId.set(import_node_path22.default.basename(service.dir), service.node.id);
+    hostToNodeId.set(import_node_path23.default.basename(service.dir), service.node.id);
     hostToNodeId.set(service.pkg.name, service.node.id);
   }
   let nodesAdded = 0;
@@ -4315,7 +4354,7 @@ async function addHttpCallEdges(graph, services) {
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (isTestPath(file.path)) continue;
-      const parser = import_node_path22.default.extname(file.path) === ".py" ? pyParser : jsParser;
+      const parser = import_node_path23.default.extname(file.path) === ".py" ? pyParser : jsParser;
       let sites;
       try {
         sites = callsFromSource(file.content, parser, knownHosts);
@@ -4324,7 +4363,7 @@ async function addHttpCallEdges(graph, services) {
         continue;
       }
       if (sites.length === 0) continue;
-      const relFile = toPosix2(import_node_path22.default.relative(service.dir, file.path));
+      const relFile = toPosix2(import_node_path23.default.relative(service.dir, file.path));
       for (const site of sites) {
         const targetId = hostToNodeId.get(site.host);
         if (!targetId || targetId === service.node.id) continue;
@@ -4378,7 +4417,7 @@ async function addHttpCallEdges(graph, services) {
 // src/extract/calls/kafka.ts
 init_cjs_shims();
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 var import_types12 = require("@neat.is/types");
 var PRODUCER_TOPIC_RE = /(?:producer|kafkaProducer)[\s\S]{0,40}?\.send\s*\(\s*\{[\s\S]{0,200}?topic\s*:\s*['"`]([^'"`]+)['"`]/g;
 var CONSUMER_TOPIC_RE = /(?:consumer|kafkaConsumer)[\s\S]{0,40}?\.(?:subscribe|run)\s*\(\s*\{[\s\S]{0,200}?topic[s]?\s*:\s*(?:\[\s*)?['"`]([^'"`]+)['"`]/g;
@@ -4409,7 +4448,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path23.default.relative(serviceDir, file.path),
+        file: import_node_path24.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -4422,7 +4461,7 @@ function kafkaEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/redis.ts
 init_cjs_shims();
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 var import_types13 = require("@neat.is/types");
 var REDIS_URL_RE = /redis(?:s)?:\/\/(?:[^@'"`\s]+@)?([^:/'"`\s]+)(?::(\d+))?/g;
 function redisEndpointsFromFile(file, serviceDir) {
@@ -4445,7 +4484,7 @@ function redisEndpointsFromFile(file, serviceDir) {
       // support tier (ADR-066).
       confidenceKind: "url-with-structural-support",
       evidence: {
-        file: import_node_path24.default.relative(serviceDir, file.path),
+        file: import_node_path25.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -4456,7 +4495,7 @@ function redisEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/aws.ts
 init_cjs_shims();
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_types14 = require("@neat.is/types");
 var S3_BUCKET_RE = /Bucket\s*:\s*['"`]([^'"`]+)['"`]/g;
 var DYNAMO_TABLE_RE = /TableName\s*:\s*['"`]([^'"`]+)['"`]/g;
@@ -4490,7 +4529,7 @@ function awsEndpointsFromFile(file, serviceDir) {
       // (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path25.default.relative(serviceDir, file.path),
+        file: import_node_path26.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -4515,7 +4554,7 @@ function awsEndpointsFromFile(file, serviceDir) {
 // src/extract/calls/grpc.ts
 init_cjs_shims();
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 var import_types15 = require("@neat.is/types");
 var GRPC_CLIENT_RE = /new\s+([A-Z][A-Za-z0-9_]*)Client\s*\(\s*['"`]?([^,'"`)]+)?/g;
 var AWS_SDK_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@aws-sdk\/client-([a-z0-9-]+)['"`]/g;
@@ -4574,7 +4613,7 @@ function grpcEndpointsFromFile(file, serviceDir) {
       // tier (ADR-066).
       confidenceKind: "verified-call-site",
       evidence: {
-        file: import_node_path26.default.relative(serviceDir, file.path),
+        file: import_node_path27.default.relative(serviceDir, file.path),
         line,
         snippet: snippet(file.content, line)
       }
@@ -4685,7 +4724,7 @@ init_cjs_shims();
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 var import_types18 = require("@neat.is/types");
 // src/extract/infra/shared.ts
@@ -4723,7 +4762,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || import_node_path27.default.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || import_node_path28.default.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -4732,7 +4771,7 @@ async function addComposeInfra(graph, scanPath, services) {
   let edgesAdded = 0;
   let composePath = null;
   for (const name of ["docker-compose.yml", "docker-compose.yaml"]) {
-    const abs = import_node_path27.default.join(scanPath, name);
+    const abs = import_node_path28.default.join(scanPath, name);
     if (await exists(abs)) {
       composePath = abs;
       break;
@@ -4745,13 +4784,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      import_node_path27.default.relative(scanPath, composePath),
+      import_node_path28.default.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = import_node_path27.default.relative(scanPath, composePath).split(import_node_path27.default.sep).join("/");
+  const evidenceFile = import_node_path28.default.relative(scanPath, composePath).split(import_node_path28.default.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -4793,8 +4832,8 @@ async function addComposeInfra(graph, scanPath, services) {
 // src/extract/infra/dockerfile.ts
 init_cjs_shims();
-var import_node_path28 = __toESM(require("path"), 1);
-var import_node_fs15 = require("fs");
+var import_node_path29 = __toESM(require("path"), 1);
+var import_node_fs16 = require("fs");
 var import_types19 = require("@neat.is/types");
 function runtimeImage(content) {
   const lines = content.split("\n");
@@ -4814,15 +4853,15 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = import_node_path28.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path29.default.join(service.dir, "Dockerfile");
     if (!await exists(dockerfilePath)) continue;
     let content;
     try {
-      content = await import_node_fs15.promises.readFile(dockerfilePath, "utf8");
+      content = await import_node_fs16.promises.readFile(dockerfilePath, "utf8");
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        import_node_path28.default.relative(scanPath, dockerfilePath),
+        import_node_path29.default.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -4834,7 +4873,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix2(import_node_path28.default.relative(service.dir, dockerfilePath));
+    const relDockerfile = toPosix2(import_node_path29.default.relative(service.dir, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -4853,7 +4892,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
         provenance: import_types19.Provenance.EXTRACTED,
         confidence: (0, import_types19.confidenceForExtracted)("structural"),
         evidence: {
-          file: toPosix2(import_node_path28.default.relative(scanPath, dockerfilePath))
+          file: toPosix2(import_node_path29.default.relative(scanPath, dockerfilePath))
         }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -4865,21 +4904,21 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 // src/extract/infra/terraform.ts
 init_cjs_shims();
-var import_node_fs16 = require("fs");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_fs17 = require("fs");
+var import_node_path30 = __toESM(require("path"), 1);
 var RESOURCE_RE = /resource\s+"(aws_[A-Za-z0-9_]+)"\s+"([A-Za-z0-9_-]+)"/g;
 async function walkTfFiles(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await import_node_fs16.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs17.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry2 of entries) {
     if (entry2.isDirectory()) {
       if (IGNORED_DIRS.has(entry2.name) || entry2.name === ".terraform") continue;
-      const child = import_node_path29.default.join(start, entry2.name);
+      const child = import_node_path30.default.join(start, entry2.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkTfFiles(child, depth + 1, max));
     } else if (entry2.isFile() && entry2.name.endsWith(".tf")) {
-      out.push(import_node_path29.default.join(start, entry2.name));
+      out.push(import_node_path30.default.join(start, entry2.name));
     }
   }
   return out;
@@ -4888,7 +4927,7 @@ async function addTerraformResources(graph, scanPath) {
   let nodesAdded = 0;
   const files = await walkTfFiles(scanPath);
   for (const file of files) {
-    const content = await import_node_fs16.promises.readFile(file, "utf8");
+    const content = await import_node_fs17.promises.readFile(file, "utf8");
     RESOURCE_RE.lastIndex = 0;
     let m;
     while ((m = RESOURCE_RE.exec(content)) !== null) {
@@ -4906,8 +4945,8 @@ async function addTerraformResources(graph, scanPath) {
 // src/extract/infra/k8s.ts
 init_cjs_shims();
-var import_node_fs17 = require("fs");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
+var import_node_path31 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var K8S_KIND_TO_INFRA_KIND = {
   Service: "k8s-service",
@@ -4921,15 +4960,15 @@ var K8S_KIND_TO_INFRA_KIND = {
 async function walkYamlFiles2(start, depth = 0, max = 5) {
   if (depth > max) return [];
   const out = [];
-  const entries = await import_node_fs17.promises.readdir(start, { withFileTypes: true }).catch(() => []);
+  const entries = await import_node_fs18.promises.readdir(start, { withFileTypes: true }).catch(() => []);
   for (const entry2 of entries) {
     if (entry2.isDirectory()) {
       if (IGNORED_DIRS.has(entry2.name)) continue;
-      const child = import_node_path30.default.join(start, entry2.name);
+      const child = import_node_path31.default.join(start, entry2.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles2(child, depth + 1, max));
-    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path30.default.extname(entry2.name))) {
-      out.push(import_node_path30.default.join(start, entry2.name));
+    } else if (entry2.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path31.default.extname(entry2.name))) {
+      out.push(import_node_path31.default.join(start, entry2.name));
     }
   }
   return out;
@@ -4938,7 +4977,7 @@ async function addK8sResources(graph, scanPath) {
   let nodesAdded = 0;
   const files = await walkYamlFiles2(scanPath);
   for (const file of files) {
-    const content = await import_node_fs17.promises.readFile(file, "utf8");
+    const content = await import_node_fs18.promises.readFile(file, "utf8");
     let docs;
     try {
       docs = (0, import_yaml3.parseAllDocuments)(content).map((d) => d.toJSON());
@@ -4973,12 +5012,12 @@ async function addInfra(graph, scanPath, services) {
 }
 // src/extract/index.ts
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 // src/extract/retire.ts
 init_cjs_shims();
-var import_node_fs18 = require("fs");
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_fs19 = require("fs");
+var import_node_path32 = __toESM(require("path"), 1);
 var import_types20 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
@@ -5012,11 +5051,11 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
     if (edge.provenance !== import_types20.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (import_node_path31.default.isAbsolute(evidenceFile)) {
-      if (!(0, import_node_fs18.existsSync)(evidenceFile)) toDrop.push(id);
+    if (import_node_path32.default.isAbsolute(evidenceFile)) {
+      if (!(0, import_node_fs19.existsSync)(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => (0, import_node_fs18.existsSync)(import_node_path31.default.join(base, evidenceFile)));
+    const found = bases.some((base) => (0, import_node_fs19.existsSync)(import_node_path32.default.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -5056,7 +5095,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   }
   const droppedEntries = drainDroppedExtracted();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = import_node_path32.default.join(import_node_path32.default.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = import_node_path33.default.join(import_node_path33.default.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -5328,8 +5367,8 @@ function computeDivergences(graph, opts = {}) {
 // src/persist.ts
 init_cjs_shims();
-var import_node_fs19 = require("fs");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
+var import_node_path34 = __toESM(require("path"), 1);
 var import_types22 = require("@neat.is/types");
 var SCHEMA_VERSION = 4;
 function migrateV1ToV2(payload) {
@@ -5366,7 +5405,7 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await import_node_fs19.promises.mkdir(import_node_path33.default.dirname(filePath), { recursive: true });
+  await import_node_fs20.promises.mkdir(import_node_path34.default.dirname(filePath), { recursive: true });
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -5376,13 +5415,13 @@ async function saveGraphToDisk(graph, outPath) {
     graph: graph.export()
   };
   const tmp = `${outPath}.tmp`;
-  await import_node_fs19.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
-  await import_node_fs19.promises.rename(tmp, outPath);
+  await import_node_fs20.promises.writeFile(tmp, JSON.stringify(payload), "utf8");
+  await import_node_fs20.promises.rename(tmp, outPath);
 }
 async function loadGraphFromDisk(graph, outPath) {
   let raw;
   try {
-    raw = await import_node_fs19.promises.readFile(outPath, "utf8");
+    raw = await import_node_fs20.promises.readFile(outPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -5441,8 +5480,8 @@ function startPersistLoop(graph, outPath, intervalMs = 6e4) {
 // src/gitignore.ts
 init_cjs_shims();
-var import_node_fs20 = require("fs");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_fs21 = require("fs");
+var import_node_path35 = __toESM(require("path"), 1);
 var NEAT_OUT_LINE = "neat-out/";
 var NEAT_HEADER = "# NEAT \u2014 machine-local snapshots and events";
 function isNeatOutLine(line) {
@@ -5450,15 +5489,15 @@ function isNeatOutLine(line) {
   return trimmed === "neat-out/" || trimmed === "neat-out";
 }
 async function ensureNeatOutIgnored(projectDir) {
-  const file = import_node_path34.default.join(projectDir, ".gitignore");
+  const file = import_node_path35.default.join(projectDir, ".gitignore");
   let existing = null;
   try {
-    existing = await import_node_fs20.promises.readFile(file, "utf8");
+    existing = await import_node_fs21.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   if (existing === null) {
-    await import_node_fs20.promises.writeFile(file, `${NEAT_HEADER}
+    await import_node_fs21.promises.writeFile(file, `${NEAT_HEADER}
 ${NEAT_OUT_LINE}
 `, "utf8");
     return { action: "created", file };
@@ -5471,7 +5510,7 @@ ${NEAT_OUT_LINE}
 ${NEAT_HEADER}
 ${NEAT_OUT_LINE}
 `;
-  await import_node_fs20.promises.writeFile(file, existing + appended, "utf8");
+  await import_node_fs21.promises.writeFile(file, existing + appended, "utf8");
   return { action: "added", file };
 }
@@ -5573,8 +5612,8 @@ function formatIncompat(inc) {
 // src/watch.ts
 init_cjs_shims();
-var import_node_fs26 = __toESM(require("fs"), 1);
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_fs27 = __toESM(require("fs"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_chokidar = __toESM(require("chokidar"), 1);
 // src/api.ts
@@ -5585,15 +5624,15 @@ var import_types25 = require("@neat.is/types");
 // src/extend/index.ts
 init_cjs_shims();
-var import_node_fs22 = require("fs");
-var import_node_path36 = __toESM(require("path"), 1);
+var import_node_fs23 = require("fs");
+var import_node_path37 = __toESM(require("path"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
 var import_instrumentation_registry = require("@neat.is/instrumentation-registry");
 // src/installers/package-manager.ts
 init_cjs_shims();
-var import_node_fs21 = require("fs");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_fs22 = require("fs");
+var import_node_path36 = __toESM(require("path"), 1);
 var import_node_child_process = require("child_process");
 var LOCKFILE_PRIORITY = [
   { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
@@ -5608,29 +5647,29 @@ var LOCKFILE_PRIORITY = [
 var NPM_FALLBACK_ARGS = ["install", "--no-audit", "--no-fund", "--prefer-offline"];
 async function exists2(p) {
   try {
-    await import_node_fs21.promises.access(p);
+    await import_node_fs22.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(serviceDir) {
-  let dir = import_node_path35.default.resolve(serviceDir);
+  let dir = import_node_path36.default.resolve(serviceDir);
   const stops = /* @__PURE__ */ new Set();
   for (let i = 0; i < 64; i++) {
     if (stops.has(dir)) break;
     stops.add(dir);
     for (const candidate of LOCKFILE_PRIORITY) {
-      const lockPath = import_node_path35.default.join(dir, candidate.lockfile);
+      const lockPath = import_node_path36.default.join(dir, candidate.lockfile);
       if (await exists2(lockPath)) {
         return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
       }
     }
-    const parent = import_node_path35.default.dirname(dir);
+    const parent = import_node_path36.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return { pm: "npm", cwd: import_node_path35.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+  return { pm: "npm", cwd: import_node_path36.default.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
 }
 async function runPackageManagerInstall(cmd) {
   return new Promise((resolve) => {
@@ -5672,30 +5711,30 @@ ${err.message}`
 // src/extend/index.ts
 async function fileExists2(p) {
   try {
-    await import_node_fs22.promises.access(p);
+    await import_node_fs23.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function readPackageJson(scanPath) {
-  const pkgPath = import_node_path36.default.join(scanPath, "package.json");
-  const raw = await import_node_fs22.promises.readFile(pkgPath, "utf8");
+  const pkgPath = import_node_path37.default.join(scanPath, "package.json");
+  const raw = await import_node_fs23.promises.readFile(pkgPath, "utf8");
   return JSON.parse(raw);
 }
 async function findHookFiles(scanPath) {
-  const entries = await import_node_fs22.promises.readdir(scanPath);
+  const entries = await import_node_fs23.promises.readdir(scanPath);
   return entries.filter(
     (e) => (e.startsWith("instrumentation") || e.startsWith("otel-init")) && /\.(ts|js)$/.test(e)
   ).sort();
 }
 function extendLogPath() {
-  return process.env.NEAT_EXTEND_LOG ?? import_node_path36.default.join(import_node_os2.default.homedir(), ".neat", "extend-log.ndjson");
+  return process.env.NEAT_EXTEND_LOG ?? import_node_path37.default.join(import_node_os2.default.homedir(), ".neat", "extend-log.ndjson");
 }
 async function appendExtendLog(entry2) {
   const logPath = extendLogPath();
-  await import_node_fs22.promises.mkdir(import_node_path36.default.dirname(logPath), { recursive: true });
-  await import_node_fs22.promises.appendFile(logPath, JSON.stringify(entry2) + "\n", "utf8");
+  await import_node_fs23.promises.mkdir(import_node_path37.default.dirname(logPath), { recursive: true });
+  await import_node_fs23.promises.appendFile(logPath, JSON.stringify(entry2) + "\n", "utf8");
 }
 function splicedContent(fileContent, snippet2) {
   if (fileContent.includes("__INSTRUMENTATION_BLOCK__")) {
@@ -5753,7 +5792,7 @@ function lookupInstrumentation(library, installedVersion) {
 }
 async function describeProjectInstrumentation(ctx) {
   const hookFiles = await findHookFiles(ctx.scanPath);
-  const envNeat = await fileExists2(import_node_path36.default.join(ctx.scanPath, ".env.neat"));
+  const envNeat = await fileExists2(import_node_path37.default.join(ctx.scanPath, ".env.neat"));
   const registryInstrPackages = new Set(
     (0, import_instrumentation_registry.list)().map((e) => e.instrumentation_package).filter((p) => !!p)
   );
@@ -5775,31 +5814,31 @@ async function applyExtension(ctx, args, options) {
     );
   }
   for (const file of hookFiles) {
-    const content = await import_node_fs22.promises.readFile(import_node_path36.default.join(ctx.scanPath, file), "utf8");
+    const content = await import_node_fs23.promises.readFile(import_node_path37.default.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return { library: args.library, filesTouched: [], depsAdded: [], installOutput: "", alreadyApplied: true };
     }
   }
   const primaryFile = hookFiles[0];
-  const primaryPath = import_node_path36.default.join(ctx.scanPath, primaryFile);
+  const primaryPath = import_node_path37.default.join(ctx.scanPath, primaryFile);
   const filesTouched = [];
   const depsAdded = [];
-  const pkgPath = import_node_path36.default.join(ctx.scanPath, "package.json");
+  const pkgPath = import_node_path37.default.join(ctx.scanPath, "package.json");
   const pkg = await readPackageJson(ctx.scanPath);
   if (!(pkg.dependencies ?? {})[args.instrumentation_package]) {
     pkg.dependencies = { ...pkg.dependencies ?? {}, [args.instrumentation_package]: args.version };
-    await import_node_fs22.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    await import_node_fs23.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     filesTouched.push("package.json");
     depsAdded.push(`${args.instrumentation_package}@${args.version}`);
   }
-  const hookContent = await import_node_fs22.promises.readFile(primaryPath, "utf8");
+  const hookContent = await import_node_fs23.promises.readFile(primaryPath, "utf8");
   const patched = splicedContent(hookContent, args.registration_snippet);
   if (!patched) {
     throw new Error(
       `Could not find instrumentation insertion point in ${primaryFile}. Expected __INSTRUMENTATION_BLOCK__, instrumentations.push(, or new NodeSDK(.`
     );
   }
-  await import_node_fs22.promises.writeFile(primaryPath, patched, "utf8");
+  await import_node_fs23.promises.writeFile(primaryPath, patched, "utf8");
   filesTouched.push(primaryFile);
   const cmd = await detectPackageManager(ctx.scanPath);
   const installer = options?.runInstall ?? runPackageManagerInstall;
@@ -5830,7 +5869,7 @@ async function dryRunExtension(ctx, args) {
     };
   }
   for (const file of hookFiles) {
-    const content = await import_node_fs22.promises.readFile(import_node_path36.default.join(ctx.scanPath, file), "utf8");
+    const content = await import_node_fs23.promises.readFile(import_node_path37.default.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return {
         library: args.library,
@@ -5852,7 +5891,7 @@ async function dryRunExtension(ctx, args) {
     depsToAdd.push(`${args.instrumentation_package}@${args.version}`);
     filesTouched.push("package.json");
   }
-  const hookContent = await import_node_fs22.promises.readFile(import_node_path36.default.join(ctx.scanPath, primaryFile), "utf8");
+  const hookContent = await import_node_fs23.promises.readFile(import_node_path37.default.join(ctx.scanPath, primaryFile), "utf8");
   const patched = splicedContent(hookContent, args.registration_snippet);
   if (patched) {
     filesTouched.push(primaryFile);
@@ -5867,28 +5906,28 @@ async function rollbackExtension(ctx, args) {
   if (!await fileExists2(logPath)) {
     return { undone: false, message: "no apply found for library" };
   }
-  const raw = await import_node_fs22.promises.readFile(logPath, "utf8");
+  const raw = await import_node_fs23.promises.readFile(logPath, "utf8");
   const entries = raw.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
   const match = [...entries].reverse().find((e) => e.project === ctx.project && e.library === args.library);
   if (!match) {
     return { undone: false, message: "no apply found for library" };
   }
-  const pkgPath = import_node_path36.default.join(ctx.scanPath, "package.json");
+  const pkgPath = import_node_path37.default.join(ctx.scanPath, "package.json");
   if (await fileExists2(pkgPath)) {
     const pkg = await readPackageJson(ctx.scanPath);
     if (pkg.dependencies?.[match.instrumentation_package]) {
       const { [match.instrumentation_package]: _removed, ...rest } = pkg.dependencies;
       pkg.dependencies = rest;
-      await import_node_fs22.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      await import_node_fs23.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
   }
   const hookFiles = await findHookFiles(ctx.scanPath);
   for (const file of hookFiles) {
-    const filePath = import_node_path36.default.join(ctx.scanPath, file);
-    const content = await import_node_fs22.promises.readFile(filePath, "utf8");
+    const filePath = import_node_path37.default.join(ctx.scanPath, file);
+    const content = await import_node_fs23.promises.readFile(filePath, "utf8");
     if (content.includes(match.registration_snippet)) {
       const filtered = content.split("\n").filter((line) => !line.includes(match.registration_snippet)).join("\n");
-      await import_node_fs22.promises.writeFile(filePath, filtered, "utf8");
+      await import_node_fs23.promises.writeFile(filePath, filtered, "utf8");
       break;
     }
   }
@@ -5900,7 +5939,7 @@ async function rollbackExtension(ctx, args) {
 // src/diff.ts
 init_cjs_shims();
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 async function loadSnapshotForDiff(target) {
   if (/^https?:\/\//i.test(target)) {
     const res = await fetch(target);
@@ -5909,7 +5948,7 @@ async function loadSnapshotForDiff(target) {
     }
     return await res.json();
   }
-  const raw = await import_node_fs23.promises.readFile(target, "utf8");
+  const raw = await import_node_fs24.promises.readFile(target, "utf8");
   return JSON.parse(raw);
 }
 function indexEntries(entries) {
@@ -5977,23 +6016,23 @@ function canonicalJson(value) {
 // src/projects.ts
 init_cjs_shims();
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_path38 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path37.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path37.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path37.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path37.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path37.default.join(baseDir, "policy-violations.ndjson")
+      snapshotPath: import_node_path38.default.join(baseDir, "graph.json"),
+      errorsPath: import_node_path38.default.join(baseDir, "errors.ndjson"),
+      staleEventsPath: import_node_path38.default.join(baseDir, "stale-events.ndjson"),
+      embeddingsCachePath: import_node_path38.default.join(baseDir, "embeddings.json"),
+      policyViolationsPath: import_node_path38.default.join(baseDir, "policy-violations.ndjson")
     };
   }
   return {
-    snapshotPath: import_node_path37.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path37.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path37.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path37.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path37.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    snapshotPath: import_node_path38.default.join(baseDir, `${project}.json`),
+    errorsPath: import_node_path38.default.join(baseDir, `errors.${project}.ndjson`),
+    staleEventsPath: import_node_path38.default.join(baseDir, `stale-events.${project}.ndjson`),
+    embeddingsCachePath: import_node_path38.default.join(baseDir, `embeddings.${project}.json`),
+    policyViolationsPath: import_node_path38.default.join(baseDir, `policy-violations.${project}.ndjson`)
   };
 }
 var Projects = class {
@@ -6029,25 +6068,25 @@ var Projects = class {
 // src/registry.ts
 init_cjs_shims();
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path39 = __toESM(require("path"), 1);
 var import_types24 = require("@neat.is/types");
 var LOCK_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_MS = 50;
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path38.default.resolve(override);
-  return import_node_path38.default.join(import_node_os3.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path39.default.resolve(override);
+  return import_node_path39.default.join(import_node_os3.default.homedir(), ".neat");
 }
 function registryPath() {
-  return import_node_path38.default.join(neatHome(), "projects.json");
+  return import_node_path39.default.join(neatHome(), "projects.json");
 }
 function registryLockPath() {
-  return import_node_path38.default.join(neatHome(), "projects.json.lock");
+  return import_node_path39.default.join(neatHome(), "projects.json.lock");
 }
 function daemonPidPath() {
-  return import_node_path38.default.join(neatHome(), "neatd.pid");
+  return import_node_path39.default.join(neatHome(), "neatd.pid");
 }
 function isPidAliveDefault(pid) {
   try {
@@ -6059,7 +6098,7 @@ function isPidAliveDefault(pid) {
 }
 async function readPidFile(file) {
   try {
-    const raw = await import_node_fs24.promises.readFile(file, "utf8");
+    const raw = await import_node_fs25.promises.readFile(file, "utf8");
     const pid = Number.parseInt(raw.trim(), 10);
     return Number.isInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
@@ -6107,32 +6146,32 @@ function lockHolderMessage(holder, lockPath, timeoutMs) {
   }
 }
 async function normalizeProjectPath(input) {
-  const resolved = import_node_path38.default.resolve(input);
+  const resolved = import_node_path39.default.resolve(input);
   try {
-    return await import_node_fs24.promises.realpath(resolved);
+    return await import_node_fs25.promises.realpath(resolved);
   } catch {
     return resolved;
   }
 }
 async function writeAtomically(target, contents) {
-  await import_node_fs24.promises.mkdir(import_node_path38.default.dirname(target), { recursive: true });
+  await import_node_fs25.promises.mkdir(import_node_path39.default.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await import_node_fs24.promises.open(tmp, "w");
+  const fd = await import_node_fs25.promises.open(tmp, "w");
   try {
     await fd.writeFile(contents, "utf8");
     await fd.sync();
   } finally {
     await fd.close();
   }
-  await import_node_fs24.promises.rename(tmp, target);
+  await import_node_fs25.promises.rename(tmp, target);
 }
 async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaultLockHolderProbe) {
   const deadline = Date.now() + timeoutMs;
-  await import_node_fs24.promises.mkdir(import_node_path38.default.dirname(lockPath), { recursive: true });
+  await import_node_fs25.promises.mkdir(import_node_path39.default.dirname(lockPath), { recursive: true });
   let probedHolder = false;
   while (true) {
     try {
-      const fd = await import_node_fs24.promises.open(lockPath, "wx");
+      const fd = await import_node_fs25.promises.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -6157,7 +6196,7 @@ async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaul
   }
 }
 async function releaseLock(lockPath) {
-  await import_node_fs24.promises.unlink(lockPath).catch(() => {
+  await import_node_fs25.promises.unlink(lockPath).catch(() => {
   });
 }
 async function withLock(fn) {
@@ -6173,7 +6212,7 @@ async function readRegistry() {
   const file = registryPath();
   let raw;
   try {
-    raw = await import_node_fs24.promises.readFile(file, "utf8");
+    raw = await import_node_fs25.promises.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: 1, projects: [] };
@@ -6924,8 +6963,8 @@ init_otel_grpc();
 // src/search.ts
 init_cjs_shims();
-var import_node_fs25 = require("fs");
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
+var import_node_path42 = __toESM(require("path"), 1);
 var import_node_crypto3 = require("crypto");
 var DEFAULT_LIMIT = 10;
 var NOMIC_DIM = 768;
@@ -7055,7 +7094,7 @@ async function pickEmbedder() {
 }
 async function readCache(cachePath) {
   try {
-    const raw = await import_node_fs25.promises.readFile(cachePath, "utf8");
+    const raw = await import_node_fs26.promises.readFile(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return null;
     return parsed;
@@ -7064,8 +7103,8 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  await import_node_fs25.promises.mkdir(import_node_path41.default.dirname(cachePath), { recursive: true });
-  await import_node_fs25.promises.writeFile(cachePath, JSON.stringify(cache));
+  await import_node_fs26.promises.mkdir(import_node_path42.default.dirname(cachePath), { recursive: true });
+  await import_node_fs26.promises.writeFile(cachePath, JSON.stringify(cache));
 }
 var VectorIndex = class {
   constructor(embedder, cachePath) {
@@ -7221,8 +7260,8 @@ var ALL_PHASES = [
 ];
 function classifyChange(relPath) {
   const phases = /* @__PURE__ */ new Set();
-  const base = import_node_path42.default.basename(relPath).toLowerCase();
-  const segments = relPath.split(import_node_path42.default.sep).map((s) => s.toLowerCase());
+  const base = import_node_path43.default.basename(relPath).toLowerCase();
+  const segments = relPath.split(import_node_path43.default.sep).map((s) => s.toLowerCase());
   if (base === "package.json" || base === "requirements.txt" || base === "pyproject.toml" || base === "setup.py") {
     phases.add("services");
     phases.add("aliases");
@@ -7336,16 +7375,16 @@ function countWatchableDirs(scanPath, limit) {
     if (count >= limit) return;
     let entries;
     try {
-      entries = import_node_fs26.default.readdirSync(dir, { withFileTypes: true });
+      entries = import_node_fs27.default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (count >= limit) return;
       if (!e.isDirectory()) continue;
-      if (IGNORED_WATCH_PATHS.some((re) => re.test(import_node_path42.default.join(dir, e.name) + import_node_path42.default.sep))) continue;
+      if (IGNORED_WATCH_PATHS.some((re) => re.test(import_node_path43.default.join(dir, e.name) + import_node_path43.default.sep))) continue;
       count++;
-      if (depth < 2) visit(import_node_path42.default.join(dir, e.name), depth + 1);
+      if (depth < 2) visit(import_node_path43.default.join(dir, e.name), depth + 1);
     }
   };
   visit(scanPath, 0);
@@ -7363,8 +7402,8 @@ async function startWatch(graph, opts) {
   const projectName = opts.project ?? DEFAULT_PROJECT;
   await loadGraphFromDisk(graph, opts.outPath);
   const detachEventBus = attachGraphToEventBus(graph, { project: projectName });
-  const policyFilePath = import_node_path42.default.join(opts.scanPath, "policy.json");
-  const policyViolationsPath = import_node_path42.default.join(import_node_path42.default.dirname(opts.outPath), "policy-violations.ndjson");
+  const policyFilePath = import_node_path43.default.join(opts.scanPath, "policy.json");
+  const policyViolationsPath = import_node_path43.default.join(import_node_path43.default.dirname(opts.outPath), "policy-violations.ndjson");
   let policies = [];
   try {
     policies = await loadPolicyFile(policyFilePath);
@@ -7415,7 +7454,7 @@ async function startWatch(graph, opts) {
   assertBindAuthority(host, auth.authToken);
   const port = opts.port ?? 8080;
   const otelPort = opts.otelPort ?? 4318;
-  const cachePath = opts.embeddingsCachePath ?? import_node_path42.default.join(import_node_path42.default.dirname(opts.outPath), "embeddings.json");
+  const cachePath = opts.embeddingsCachePath ?? import_node_path43.default.join(import_node_path43.default.dirname(opts.outPath), "embeddings.json");
   let searchIndex;
   try {
     searchIndex = await buildSearchIndex(graph, { cachePath });
@@ -7433,7 +7472,7 @@ async function startWatch(graph, opts) {
       // Paths are derived from the explicit options the watch caller passes
       // — pathsForProject is only used to fill in the embeddings/snapshot
       // fields so the registry shape is complete.
-      ...pathsForProject(projectName, import_node_path42.default.dirname(opts.outPath)),
+      ...pathsForProject(projectName, import_node_path43.default.dirname(opts.outPath)),
       snapshotPath: opts.outPath,
       errorsPath: opts.errorsPath,
       staleEventsPath: opts.staleEventsPath
@@ -7520,9 +7559,9 @@ async function startWatch(graph, opts) {
   };
   const onPath = (absPath) => {
     if (shouldIgnore(absPath)) return;
-    const rel = import_node_path42.default.relative(opts.scanPath, absPath);
+    const rel = import_node_path43.default.relative(opts.scanPath, absPath);
     if (!rel || rel.startsWith("..")) return;
-    pendingPaths.add(rel.split(import_node_path42.default.sep).join("/"));
+    pendingPaths.add(rel.split(import_node_path43.default.sep).join("/"));
     const phases = classifyChange(rel);
     if (phases.size === 0) {
       for (const p of ALL_PHASES) pending.add(p);
@@ -7576,8 +7615,8 @@ async function startWatch(graph, opts) {
 // src/deploy/detect.ts
 init_cjs_shims();
-var import_node_fs27 = require("fs");
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_fs28 = require("fs");
+var import_node_path44 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_crypto4 = require("crypto");
 function generateToken() {
@@ -7677,21 +7716,21 @@ async function runDeploy(opts = {}) {
   const token = generateToken();
   switch (substrate) {
     case "docker-compose": {
-      const artifactPath = import_node_path43.default.join(cwd, "docker-compose.neat.yml");
+      const artifactPath = import_node_path44.default.join(cwd, "docker-compose.neat.yml");
       const contents = emitDockerCompose(cwd);
-      await import_node_fs27.promises.writeFile(artifactPath, contents, "utf8");
+      await import_node_fs28.promises.writeFile(artifactPath, contents, "utf8");
       return {
         substrate,
         artifactPath,
         token,
         contents,
-        startCommand: `NEAT_AUTH_TOKEN=${token} docker compose -f ${import_node_path43.default.basename(artifactPath)} up -d`
+        startCommand: `NEAT_AUTH_TOKEN=${token} docker compose -f ${import_node_path44.default.basename(artifactPath)} up -d`
       };
     }
     case "systemd": {
-      const artifactPath = import_node_path43.default.join(cwd, "neat.service");
+      const artifactPath = import_node_path44.default.join(cwd, "neat.service");
       const contents = emitSystemdUnit(cwd);
-      await import_node_fs27.promises.writeFile(artifactPath, contents, "utf8");
+      await import_node_fs28.promises.writeFile(artifactPath, contents, "utf8");
       return {
         substrate,
         artifactPath,
@@ -7724,8 +7763,8 @@ init_cjs_shims();
 // src/installers/javascript.ts
 init_cjs_shims();
-var import_node_fs28 = require("fs");
-var import_node_path44 = __toESM(require("path"), 1);
+var import_node_fs29 = require("fs");
+var import_node_path45 = __toESM(require("path"), 1);
 var import_semver2 = __toESM(require("semver"), 1);
 // src/installers/templates.ts
@@ -8272,15 +8311,15 @@ var OTEL_ENV = {
   value: "http://localhost:4318/projects/<project>/v1/traces"
 };
 function serviceNodeName(pkg, serviceDir) {
-  return pkg.name ?? import_node_path44.default.basename(serviceDir);
+  return pkg.name ?? import_node_path45.default.basename(serviceDir);
 }
 function projectToken(pkg, serviceDir, project) {
   if (project && project.length > 0) return project;
-  return pkg.name ?? import_node_path44.default.basename(serviceDir);
+  return pkg.name ?? import_node_path45.default.basename(serviceDir);
 }
 async function readJsonFile(p) {
   try {
-    const raw = await import_node_fs28.promises.readFile(p, "utf8");
+    const raw = await import_node_fs29.promises.readFile(p, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -8289,16 +8328,16 @@ async function readJsonFile(p) {
 async function detectRuntimeKind(pkgRoot, pkg) {
   const deps = allDeps(pkg);
   if ("react-native" in deps || "expo" in deps) return "react-native";
-  const appJson = await readJsonFile(import_node_path44.default.join(pkgRoot, "app.json"));
+  const appJson = await readJsonFile(import_node_path45.default.join(pkgRoot, "app.json"));
   if (appJson && typeof appJson === "object" && "expo" in appJson) {
     return "react-native";
   }
-  if (await exists3(import_node_path44.default.join(pkgRoot, "vite.config.js")) || await exists3(import_node_path44.default.join(pkgRoot, "vite.config.ts")) || await exists3(import_node_path44.default.join(pkgRoot, "vite.config.mjs")) || "vite" in deps) {
+  if (await exists3(import_node_path45.default.join(pkgRoot, "vite.config.js")) || await exists3(import_node_path45.default.join(pkgRoot, "vite.config.ts")) || await exists3(import_node_path45.default.join(pkgRoot, "vite.config.mjs")) || "vite" in deps) {
     return "browser-bundle";
   }
-  if (await exists3(import_node_path44.default.join(pkgRoot, "wrangler.toml"))) return "cloudflare-workers";
-  if (await exists3(import_node_path44.default.join(pkgRoot, "bun.lockb"))) return "bun";
-  if (await exists3(import_node_path44.default.join(pkgRoot, "deno.json")) || await exists3(import_node_path44.default.join(pkgRoot, "deno.lock"))) {
+  if (await exists3(import_node_path45.default.join(pkgRoot, "wrangler.toml"))) return "cloudflare-workers";
+  if (await exists3(import_node_path45.default.join(pkgRoot, "bun.lockb"))) return "bun";
+  if (await exists3(import_node_path45.default.join(pkgRoot, "deno.json")) || await exists3(import_node_path45.default.join(pkgRoot, "deno.lock"))) {
     return "deno";
   }
   const engines = pkg.engines ?? {};
@@ -8307,7 +8346,7 @@ async function detectRuntimeKind(pkgRoot, pkg) {
 }
 async function readPackageJson2(serviceDir) {
   try {
-    const raw = await import_node_fs28.promises.readFile(import_node_path44.default.join(serviceDir, "package.json"), "utf8");
+    const raw = await import_node_fs29.promises.readFile(import_node_path45.default.join(serviceDir, "package.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -8315,7 +8354,7 @@ async function readPackageJson2(serviceDir) {
 }
 async function exists3(p) {
   try {
-    await import_node_fs28.promises.stat(p);
+    await import_node_fs29.promises.stat(p);
     return true;
   } catch {
     return false;
@@ -8323,7 +8362,7 @@ async function exists3(p) {
 }
 async function readFileMaybe(p) {
   try {
-    return await import_node_fs28.promises.readFile(p, "utf8");
+    return await import_node_fs29.promises.readFile(p, "utf8");
   } catch {
     return null;
   }
@@ -8351,7 +8390,7 @@ function needsVersionUpgrade(installed, expected) {
 var NEXT_CONFIG_CANDIDATES = ["next.config.js", "next.config.ts", "next.config.mjs"];
 async function findNextConfig(serviceDir) {
   for (const name of NEXT_CONFIG_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, name);
+    const candidate = import_node_path45.default.join(serviceDir, name);
     if (await exists3(candidate)) return candidate;
   }
   return null;
@@ -8378,7 +8417,7 @@ function hasRemixDependency(pkg) {
 }
 async function findRemixEntry(serviceDir) {
   for (const rel of REMIX_ENTRY_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, rel);
+    const candidate = import_node_path45.default.join(serviceDir, rel);
     if (await exists3(candidate)) return candidate;
   }
   return null;
@@ -8390,14 +8429,14 @@ function hasSvelteKitDependency(pkg) {
 }
 async function findSvelteKitHooks(serviceDir) {
   for (const rel of SVELTEKIT_HOOKS_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, rel);
+    const candidate = import_node_path45.default.join(serviceDir, rel);
     if (await exists3(candidate)) return candidate;
   }
   return null;
 }
 async function findSvelteKitConfig(serviceDir) {
   for (const rel of SVELTEKIT_CONFIG_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, rel);
+    const candidate = import_node_path45.default.join(serviceDir, rel);
     if (await exists3(candidate)) return candidate;
   }
   return null;
@@ -8408,7 +8447,7 @@ function hasNuxtDependency(pkg) {
 }
 async function findNuxtConfig(serviceDir) {
   for (const name of NUXT_CONFIG_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, name);
+    const candidate = import_node_path45.default.join(serviceDir, name);
     if (await exists3(candidate)) return candidate;
   }
   return null;
@@ -8419,7 +8458,7 @@ function hasAstroDependency(pkg) {
 }
 async function findAstroConfig(serviceDir) {
   for (const name of ASTRO_CONFIG_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, name);
+    const candidate = import_node_path45.default.join(serviceDir, name);
     if (await exists3(candidate)) return candidate;
   }
   return null;
@@ -8433,7 +8472,7 @@ function parseNextMajor(range) {
   return Number.isFinite(n) ? n : null;
 }
 async function isTypeScriptProject(serviceDir) {
-  return exists3(import_node_path44.default.join(serviceDir, "tsconfig.json"));
+  return exists3(import_node_path45.default.join(serviceDir, "tsconfig.json"));
 }
 var INDEX_EXTENSIONS = [".ts", ".tsx", ".js", ".mjs", ".cjs"];
 var INDEX_CANDIDATES = INDEX_EXTENSIONS.map((ext) => `index${ext}`);
@@ -8479,7 +8518,7 @@ function entryFromScript(script) {
 }
 async function resolveEntry(serviceDir, pkg) {
   if (typeof pkg.main === "string" && pkg.main.length > 0) {
-    const candidate = import_node_path44.default.resolve(serviceDir, pkg.main);
+    const candidate = import_node_path45.default.resolve(serviceDir, pkg.main);
     if (await exists3(candidate)) return candidate;
   }
   if (pkg.bin) {
@@ -8493,36 +8532,36 @@ async function resolveEntry(serviceDir, pkg) {
       if (typeof first === "string") binEntry = first;
     }
     if (binEntry) {
-      const candidate = import_node_path44.default.resolve(serviceDir, binEntry);
+      const candidate = import_node_path45.default.resolve(serviceDir, binEntry);
       if (await exists3(candidate)) return candidate;
     }
   }
   const startEntry = entryFromScript(pkg.scripts?.start);
   if (startEntry) {
-    const candidate = import_node_path44.default.resolve(serviceDir, startEntry);
+    const candidate = import_node_path45.default.resolve(serviceDir, startEntry);
     if (await exists3(candidate)) return candidate;
   }
   const devEntry = entryFromScript(pkg.scripts?.dev);
   if (devEntry) {
-    const candidate = import_node_path44.default.resolve(serviceDir, devEntry);
+    const candidate = import_node_path45.default.resolve(serviceDir, devEntry);
     if (await exists3(candidate)) return candidate;
   }
   for (const rel of SRC_INDEX_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, rel);
+    const candidate = import_node_path45.default.join(serviceDir, rel);
     if (await exists3(candidate)) return candidate;
   }
   for (const rel of SRC_NAMED_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, rel);
+    const candidate = import_node_path45.default.join(serviceDir, rel);
     if (await exists3(candidate)) return candidate;
   }
   for (const name of INDEX_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, name);
+    const candidate = import_node_path45.default.join(serviceDir, name);
     if (await exists3(candidate)) return candidate;
   }
   return null;
 }
 function dispatchEntry(entryFile, pkg) {
-  const ext = import_node_path44.default.extname(entryFile).toLowerCase();
+  const ext = import_node_path45.default.extname(entryFile).toLowerCase();
   if (ext === ".ts" || ext === ".tsx") return "ts";
   if (ext === ".mjs") return "esm";
   if (ext === ".cjs") return "cjs";
@@ -8539,9 +8578,9 @@ function otelInitContents(flavor) {
   return OTEL_INIT_CJS;
 }
 function injectionLine(flavor, entryFile, otelInitFile) {
-  let rel = import_node_path44.default.relative(import_node_path44.default.dirname(entryFile), otelInitFile);
+  let rel = import_node_path45.default.relative(import_node_path45.default.dirname(entryFile), otelInitFile);
   if (!rel.startsWith(".")) rel = `./${rel}`;
-  rel = rel.split(import_node_path44.default.sep).join("/");
+  rel = rel.split(import_node_path45.default.sep).join("/");
   if (flavor === "cjs") return `require('${rel}')`;
   if (flavor === "esm") return `import '${rel}'`;
   const tsRel = rel.replace(/\.ts$/, "");
@@ -8554,23 +8593,23 @@ function lineIsOtelInjection(line) {
 }
 async function detectsSrcLayout(serviceDir) {
   const [hasSrcApp, hasSrcPages, hasRootApp, hasRootPages] = await Promise.all([
-    exists3(import_node_path44.default.join(serviceDir, "src", "app")),
-    exists3(import_node_path44.default.join(serviceDir, "src", "pages")),
-    exists3(import_node_path44.default.join(serviceDir, "app")),
-    exists3(import_node_path44.default.join(serviceDir, "pages"))
+    exists3(import_node_path45.default.join(serviceDir, "src", "app")),
+    exists3(import_node_path45.default.join(serviceDir, "src", "pages")),
+    exists3(import_node_path45.default.join(serviceDir, "app")),
+    exists3(import_node_path45.default.join(serviceDir, "pages"))
   ]);
   return (hasSrcApp || hasSrcPages) && !hasRootApp && !hasRootPages;
 }
 async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project) {
   const useTs = await isTypeScriptProject(serviceDir);
   const srcLayout = await detectsSrcLayout(serviceDir);
-  const baseDir = srcLayout ? import_node_path44.default.join(serviceDir, "src") : serviceDir;
-  const instrumentationFile = import_node_path44.default.join(baseDir, useTs ? "instrumentation.ts" : "instrumentation.js");
-  const instrumentationNodeFile = import_node_path44.default.join(
+  const baseDir = srcLayout ? import_node_path45.default.join(serviceDir, "src") : serviceDir;
+  const instrumentationFile = import_node_path45.default.join(baseDir, useTs ? "instrumentation.ts" : "instrumentation.js");
+  const instrumentationNodeFile = import_node_path45.default.join(
     baseDir,
     useTs ? "instrumentation.node.ts" : "instrumentation.node.js"
   );
-  const envNeatFile = import_node_path44.default.join(baseDir, ".env.neat");
+  const envNeatFile = import_node_path45.default.join(baseDir, ".env.neat");
   const existingDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const dependencyEdits = [];
   for (const sdk of SDK_PACKAGES) {
@@ -8627,7 +8666,7 @@ async function planNext(serviceDir, pkg, manifestPath, nextConfigPath, project)
   const nextMajor = parseNextMajor(nextRange);
   if (nextMajor !== null && nextMajor < 15) {
     try {
-      const raw = await import_node_fs28.promises.readFile(nextConfigPath, "utf8");
+      const raw = await import_node_fs29.promises.readFile(nextConfigPath, "utf8");
       if (!raw.includes("instrumentationHook")) {
         nextConfigEdit = {
           file: nextConfigPath,
@@ -8675,7 +8714,7 @@ function buildDependencyEdits(pkg, manifestPath) {
   return edits;
 }
 async function queueEnvNeat(serviceDir, pkg, project, generatedFiles) {
-  const envNeatFile = import_node_path44.default.join(serviceDir, ".env.neat");
+  const envNeatFile = import_node_path45.default.join(serviceDir, ".env.neat");
   if (!await exists3(envNeatFile)) {
     generatedFiles.push({
       file: envNeatFile,
@@ -8710,7 +8749,7 @@ function fileImportsOtelHook(raw, specifiers) {
 }
 async function planRemix(serviceDir, pkg, manifestPath, entryFile, project) {
   const useTs = await isTypeScriptProject(serviceDir);
-  const otelServerFile = import_node_path44.default.join(
+  const otelServerFile = import_node_path45.default.join(
     serviceDir,
     useTs ? "app/otel.server.ts" : "app/otel.server.js"
   );
@@ -8731,7 +8770,7 @@ async function planRemix(serviceDir, pkg, manifestPath, entryFile, project) {
   await queueEnvNeat(serviceDir, pkg, project, generatedFiles);
   const entrypointEdits = [];
   try {
-    const raw = await import_node_fs28.promises.readFile(entryFile, "utf8");
+    const raw = await import_node_fs29.promises.readFile(entryFile, "utf8");
     if (!fileImportsOtelHook(raw, ["./otel.server"])) {
       const lines = raw.split(/\r?\n/);
       const firstReal = lines[0]?.startsWith("#!") ? lines[1] ?? "" : lines[0] ?? "";
@@ -8767,11 +8806,11 @@ async function planRemix(serviceDir, pkg, manifestPath, entryFile, project) {
 }
 async function planSvelteKit(serviceDir, pkg, manifestPath, hooksFile, project) {
   const useTs = await isTypeScriptProject(serviceDir);
-  const otelInitFile = import_node_path44.default.join(
+  const otelInitFile = import_node_path45.default.join(
     serviceDir,
     useTs ? "src/otel-init.ts" : "src/otel-init.js"
   );
-  const resolvedHooksFile = hooksFile ?? import_node_path44.default.join(serviceDir, useTs ? "src/hooks.server.ts" : "src/hooks.server.js");
+  const resolvedHooksFile = hooksFile ?? import_node_path45.default.join(serviceDir, useTs ? "src/hooks.server.ts" : "src/hooks.server.js");
   const dependencyEdits = buildDependencyEdits(pkg, manifestPath);
   const generatedFiles = [];
   const entrypointEdits = [];
@@ -8796,7 +8835,7 @@ async function planSvelteKit(serviceDir, pkg, manifestPath, hooksFile, project)
     });
   } else {
     try {
-      const raw = await import_node_fs28.promises.readFile(hooksFile, "utf8");
+      const raw = await import_node_fs29.promises.readFile(hooksFile, "utf8");
       if (!fileImportsOtelHook(raw, ["./otel-init"])) {
         const lines = raw.split(/\r?\n/);
         const firstReal = lines[0]?.startsWith("#!") ? lines[1] ?? "" : lines[0] ?? "";
@@ -8833,11 +8872,11 @@ async function planSvelteKit(serviceDir, pkg, manifestPath, hooksFile, project)
 }
 async function planNuxt(serviceDir, pkg, manifestPath, project) {
   const useTs = await isTypeScriptProject(serviceDir);
-  const otelPluginFile = import_node_path44.default.join(
+  const otelPluginFile = import_node_path45.default.join(
     serviceDir,
     useTs ? "server/plugins/otel.ts" : "server/plugins/otel.js"
   );
-  const otelInitFile = import_node_path44.default.join(
+  const otelInitFile = import_node_path45.default.join(
     serviceDir,
     useTs ? "server/plugins/otel-init.ts" : "server/plugins/otel-init.js"
   );
@@ -8888,19 +8927,19 @@ async function planNuxt(serviceDir, pkg, manifestPath, project) {
 var ASTRO_MIDDLEWARE_CANDIDATES = ["src/middleware.ts", "src/middleware.js"];
 async function findAstroMiddleware(serviceDir) {
   for (const rel of ASTRO_MIDDLEWARE_CANDIDATES) {
-    const candidate = import_node_path44.default.join(serviceDir, rel);
+    const candidate = import_node_path45.default.join(serviceDir, rel);
     if (await exists3(candidate)) return candidate;
   }
   return null;
 }
 async function planAstro(serviceDir, pkg, manifestPath, project) {
   const useTs = await isTypeScriptProject(serviceDir);
-  const otelInitFile = import_node_path44.default.join(
+  const otelInitFile = import_node_path45.default.join(
     serviceDir,
     useTs ? "src/otel-init.ts" : "src/otel-init.js"
   );
   const existingMiddleware = await findAstroMiddleware(serviceDir);
-  const middlewareFile = existingMiddleware ?? import_node_path44.default.join(serviceDir, useTs ? "src/middleware.ts" : "src/middleware.js");
+  const middlewareFile = existingMiddleware ?? import_node_path45.default.join(serviceDir, useTs ? "src/middleware.ts" : "src/middleware.js");
   const dependencyEdits = buildDependencyEdits(pkg, manifestPath);
   const generatedFiles = [];
   const entrypointEdits = [];
@@ -8925,7 +8964,7 @@ async function planAstro(serviceDir, pkg, manifestPath, project) {
     });
   } else {
     try {
-      const raw = await import_node_fs28.promises.readFile(existingMiddleware, "utf8");
+      const raw = await import_node_fs29.promises.readFile(existingMiddleware, "utf8");
       if (!fileImportsOtelHook(raw, ["./otel-init"])) {
         const lines = raw.split(/\r?\n/);
         const firstReal = lines[0]?.startsWith("#!") ? lines[1] ?? "" : lines[0] ?? "";
@@ -8996,7 +9035,7 @@ async function findFrameworkDispatch(serviceDir, pkg, manifestPath, project) {
 }
 async function plan(serviceDir, opts) {
   const pkg = await readPackageJson2(serviceDir);
-  const manifestPath = import_node_path44.default.join(serviceDir, "package.json");
+  const manifestPath = import_node_path45.default.join(serviceDir, "package.json");
   const project = opts?.project;
   const empty = {
     language: "javascript",
@@ -9031,8 +9070,8 @@ async function plan(serviceDir, opts) {
     return { ...empty, libOnly: true };
   }
   const flavor = dispatchEntry(entryFile, pkg);
-  const otelInitFile = import_node_path44.default.join(import_node_path44.default.dirname(entryFile), otelInitFilename(flavor));
-  const envNeatFile = import_node_path44.default.join(serviceDir, ".env.neat");
+  const otelInitFile = import_node_path45.default.join(import_node_path45.default.dirname(entryFile), otelInitFilename(flavor));
+  const envNeatFile = import_node_path45.default.join(serviceDir, ".env.neat");
   const existingDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const dependencyEdits = [];
   for (const sdk of SDK_PACKAGES) {
@@ -9056,7 +9095,7 @@ async function plan(serviceDir, opts) {
   }
   const entrypointEdits = [];
   try {
-    const raw = await import_node_fs28.promises.readFile(entryFile, "utf8");
+    const raw = await import_node_fs29.promises.readFile(entryFile, "utf8");
     const lines = raw.split(/\r?\n/);
     const firstReal = lines[0]?.startsWith("#!") ? lines[1] ?? "" : lines[0] ?? "";
     if (!lineIsOtelInjection(firstReal)) {
@@ -9101,13 +9140,13 @@ async function plan(serviceDir, opts) {
   };
 }
 function isAllowedWritePath(serviceDir, target) {
-  const rel = import_node_path44.default.relative(serviceDir, target);
+  const rel = import_node_path45.default.relative(serviceDir, target);
   if (rel.startsWith("..")) return false;
-  const base = import_node_path44.default.basename(target);
+  const base = import_node_path45.default.basename(target);
   if (base === "package.json") return true;
   if (base === ".env.neat") return true;
   if (/^otel-init\.(?:js|cjs|mjs|ts)$/.test(base)) return true;
-  const relPosix = rel.split(import_node_path44.default.sep).join("/");
+  const relPosix = rel.split(import_node_path45.default.sep).join("/");
   if (/^instrumentation(?:\.node)?\.(?:js|cjs|mjs|ts)$/.test(base)) {
     if (relPosix === base) return true;
     if (relPosix === `src/${base}`) return true;
@@ -9124,10 +9163,10 @@ function isAllowedWritePath(serviceDir, target) {
   return false;
 }
 async function writeAtomic(file, contents) {
-  await import_node_fs28.promises.mkdir(import_node_path44.default.dirname(file), { recursive: true });
+  await import_node_fs29.promises.mkdir(import_node_path45.default.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  await import_node_fs28.promises.writeFile(tmp, contents, "utf8");
-  await import_node_fs28.promises.rename(tmp, file);
+  await import_node_fs29.promises.writeFile(tmp, contents, "utf8");
+  await import_node_fs29.promises.rename(tmp, file);
 }
 async function apply(installPlan) {
   const { serviceDir } = installPlan;
@@ -9203,7 +9242,7 @@ async function apply(installPlan) {
   for (const target of allTargets) {
     if (await exists3(target)) {
       try {
-        originals.set(target, await import_node_fs28.promises.readFile(target, "utf8"));
+        originals.set(target, await import_node_fs29.promises.readFile(target, "utf8"));
       } catch {
       }
     }
@@ -9286,14 +9325,14 @@ async function rollback(installPlan, originals, createdFiles) {
   const removed = [];
   for (const [file, raw] of originals.entries()) {
     try {
-      await import_node_fs28.promises.writeFile(file, raw, "utf8");
+      await import_node_fs29.promises.writeFile(file, raw, "utf8");
       restored.push(file);
     } catch {
     }
   }
   for (const file of createdFiles) {
     try {
-      await import_node_fs28.promises.unlink(file);
+      await import_node_fs29.promises.unlink(file);
       removed.push(file);
     } catch {
     }
@@ -9308,8 +9347,8 @@ async function rollback(installPlan, originals, createdFiles) {
     ...removed.map((f) => `removed:  ${f}`),
     ""
   ];
-  const rollbackPath = import_node_path44.default.join(installPlan.serviceDir, "neat-rollback.patch");
-  await import_node_fs28.promises.writeFile(rollbackPath, lines.join("\n"), "utf8");
+  const rollbackPath = import_node_path45.default.join(installPlan.serviceDir, "neat-rollback.patch");
+  await import_node_fs29.promises.writeFile(rollbackPath, lines.join("\n"), "utf8");
 }
 function injectInstrumentationHook(raw) {
   if (raw.includes("instrumentationHook")) return raw;
@@ -9338,8 +9377,8 @@ var javascriptInstaller = {
 // src/installers/python.ts
 init_cjs_shims();
-var import_node_fs29 = require("fs");
-var import_node_path45 = __toESM(require("path"), 1);
+var import_node_fs30 = require("fs");
+var import_node_path46 = __toESM(require("path"), 1);
 var SDK_PACKAGES2 = [
   { name: "opentelemetry-distro", version: ">=0.49b0" },
   { name: "opentelemetry-exporter-otlp", version: ">=1.28.0" }
@@ -9351,7 +9390,7 @@ var OTEL_ENV2 = {
 };
 async function exists4(p) {
   try {
-    await import_node_fs29.promises.stat(p);
+    await import_node_fs30.promises.stat(p);
     return true;
   } catch {
     return false;
@@ -9360,7 +9399,7 @@ async function exists4(p) {
 async function detect2(serviceDir) {
   const markers = ["requirements.txt", "pyproject.toml", "setup.py"];
   for (const m of markers) {
-    if (await exists4(import_node_path45.default.join(serviceDir, m))) return true;
+    if (await exists4(import_node_path46.default.join(serviceDir, m))) return true;
   }
   return false;
 }
@@ -9370,9 +9409,9 @@ function reqPackageName(line) {
   return head.replace(/[<>=!~].*$/, "").toLowerCase();
 }
 async function planRequirementsTxtEdits(serviceDir) {
-  const file = import_node_path45.default.join(serviceDir, "requirements.txt");
+  const file = import_node_path46.default.join(serviceDir, "requirements.txt");
   if (!await exists4(file)) return null;
-  const raw = await import_node_fs29.promises.readFile(file, "utf8");
+  const raw = await import_node_fs30.promises.readFile(file, "utf8");
   const presentNames = new Set(
     raw.split(/\r?\n/).map(reqPackageName).filter((n) => n.length > 0)
   );
@@ -9380,9 +9419,9 @@ async function planRequirementsTxtEdits(serviceDir) {
   return { manifest: file, missing: [...missing] };
 }
 async function planProcfileEdits(serviceDir) {
-  const procfile = import_node_path45.default.join(serviceDir, "Procfile");
+  const procfile = import_node_path46.default.join(serviceDir, "Procfile");
   if (!await exists4(procfile)) return [];
-  const raw = await import_node_fs29.promises.readFile(procfile, "utf8");
+  const raw = await import_node_fs30.promises.readFile(procfile, "utf8");
   const edits = [];
   for (const line of raw.split(/\r?\n/)) {
     if (line.length === 0) continue;
@@ -9434,8 +9473,8 @@ async function applyRequirementsTxt(manifest, edits, original) {
   const next = `${original}${trailing}${newlines.join("\n")}
 `;
   const tmp = `${manifest}.${process.pid}.${Date.now()}.tmp`;
-  await import_node_fs29.promises.writeFile(tmp, next, "utf8");
-  await import_node_fs29.promises.rename(tmp, manifest);
+  await import_node_fs30.promises.writeFile(tmp, next, "utf8");
+  await import_node_fs30.promises.rename(tmp, manifest);
 }
 async function applyProcfile(procfile, edits, original) {
   let next = original;
@@ -9444,8 +9483,8 @@ async function applyProcfile(procfile, edits, original) {
     next = next.replace(e.before, e.after);
   }
   const tmp = `${procfile}.${process.pid}.${Date.now()}.tmp`;
-  await import_node_fs29.promises.writeFile(tmp, next, "utf8");
-  await import_node_fs29.promises.rename(tmp, procfile);
+  await import_node_fs30.promises.writeFile(tmp, next, "utf8");
+  await import_node_fs30.promises.rename(tmp, procfile);
 }
 async function apply2(installPlan) {
   const { serviceDir } = installPlan;
@@ -9458,7 +9497,7 @@ async function apply2(installPlan) {
   const originals = /* @__PURE__ */ new Map();
   for (const file of touched) {
     try {
-      originals.set(file, await import_node_fs29.promises.readFile(file, "utf8"));
+      originals.set(file, await import_node_fs30.promises.readFile(file, "utf8"));
     } catch {
     }
   }
@@ -9469,7 +9508,7 @@ async function apply2(installPlan) {
       if (raw === void 0) {
         throw new Error(`python installer: cannot read ${file} during apply`);
       }
-      const base = import_node_path45.default.basename(file);
+      const base = import_node_path46.default.basename(file);
       if (base === "requirements.txt") {
         const edits = installPlan.dependencyEdits.filter((e) => e.file === file);
         if (edits.length > 0) {
@@ -9494,7 +9533,7 @@ async function rollback2(installPlan, originals) {
   const restored = [];
   for (const [file, raw] of originals.entries()) {
     try {
-      await import_node_fs29.promises.writeFile(file, raw, "utf8");
+      await import_node_fs30.promises.writeFile(file, raw, "utf8");
       restored.push(file);
     } catch {
     }
@@ -9508,8 +9547,8 @@ async function rollback2(installPlan, originals) {
     ...restored.map((f) => `restored: ${f}`),
     ""
   ];
-  const rollbackPath = import_node_path45.default.join(installPlan.serviceDir, "neat-rollback.patch");
-  await import_node_fs29.promises.writeFile(rollbackPath, lines.join("\n"), "utf8");
+  const rollbackPath = import_node_path46.default.join(installPlan.serviceDir, "neat-rollback.patch");
+  await import_node_fs30.promises.writeFile(rollbackPath, lines.join("\n"), "utf8");
 }
 var pythonInstaller = {
   name: "python",
@@ -9632,10 +9671,10 @@ function renderPatch(sections) {
 // src/orchestrator.ts
 init_cjs_shims();
-var import_node_fs30 = require("fs");
+var import_node_fs31 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_net = __toESM(require("net"), 1);
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_path47 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_readline = __toESM(require("readline"), 1);
 async function extractAndPersist(opts) {
@@ -9644,7 +9683,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_path46.default.join(opts.scanPath, "neat-out"));
+  const projectPaths = pathsForProject(graphKey, import_node_path47.default.join(opts.scanPath, "neat-out"));
   const extraction = await extractFromDirectory(graph, opts.scanPath, {
     errorsPath: projectPaths.errorsPath
   });
@@ -9698,7 +9737,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_path46.default.basename(svc.dir);
+      const svcName = import_node_path47.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as React Native / Expo
   The installer doesn't cover this runtime deterministically.
@@ -9709,7 +9748,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "bun") {
       bun++;
-      const svcName = import_node_path46.default.basename(svc.dir);
+      const svcName = import_node_path47.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Bun
   The installer doesn't cover this runtime deterministically.
@@ -9720,7 +9759,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "deno") {
       deno++;
-      const svcName = import_node_path46.default.basename(svc.dir);
+      const svcName = import_node_path47.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Deno
   The installer doesn't cover this runtime deterministically.
@@ -9731,7 +9770,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "cloudflare-workers") {
       cloudflareWorkers++;
-      const svcName = import_node_path46.default.basename(svc.dir);
+      const svcName = import_node_path47.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Cloudflare Workers
   The installer doesn't cover this runtime deterministically.
@@ -9742,7 +9781,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "electron") {
       electron++;
-      const svcName = import_node_path46.default.basename(svc.dir);
+      const svcName = import_node_path47.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Electron
   The installer doesn't cover this runtime deterministically.
@@ -9916,10 +9955,10 @@ function formatPortCollisionMessage(port) {
   ];
 }
 function spawnDaemonDetached() {
-  const here = import_node_path46.default.dirname(new URL(importMetaUrl).pathname);
+  const here = import_node_path47.default.dirname(new URL(importMetaUrl).pathname);
   const candidates = [
-    import_node_path46.default.join(here, "neatd.cjs"),
-    import_node_path46.default.join(here, "neatd.js")
+    import_node_path47.default.join(here, "neatd.cjs"),
+    import_node_path47.default.join(here, "neatd.js")
   ];
   let entry2 = null;
   const fsSync = require("fs");
@@ -9977,12 +10016,13 @@ async function runOrchestrator(opts) {
       browser: "skipped"
     }
   };
-  const stat = await import_node_fs30.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs31.promises.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat: ${opts.scanPath} is not a directory`);
     result.exitCode = 2;
     return result;
   }
+  printBanner();
   console.log(`neat: ${opts.scanPath}`);
   console.log("");
   const persisted = await extractAndPersist({
@@ -9993,6 +10033,13 @@ async function runOrchestrator(opts) {
   const { graph, services, languages } = persisted;
   result.steps.discovery = { services: services.length, languages };
   console.log(`discovered ${services.length} service(s) across ${languages.length} language(s)`);
+  if (services.length === 0) {
+    console.error(
+      `neat: no services found in ${opts.scanPath} \u2014 run from inside your project root, or \`npx neat.is <path>\``
+    );
+    result.exitCode = 2;
+    return result;
+  }
   let runApply = !opts.noInstrument;
   if (runApply && !opts.yes && process.stdout.isTTY && process.stdin.isTTY) {
     runApply = await promptYesNo("instrument your services and open the dashboard?");
@@ -10116,11 +10163,17 @@ function printSummary(result, graph, dashboardUrl) {
   for (const [t, c] of [...byEdge.entries()].sort()) console.log(`  ${t}: ${c}`);
   console.log("");
   console.log(`dashboard: ${dashboardUrl}`);
+  const token = process.env.NEAT_AUTH_TOKEN;
+  if (typeof token === "string" && token.length > 0) {
+    console.log(`auth token: ${token}`);
+  } else {
+    console.log("running locally \u2014 open the dashboard, no token needed");
+  }
 }
 // src/cli-verbs.ts
 init_cjs_shims();
-var import_node_path47 = __toESM(require("path"), 1);
+var import_node_path48 = __toESM(require("path"), 1);
 // src/cli-client.ts
 init_cjs_shims();
@@ -10149,10 +10202,10 @@ function createHttpClient(baseUrl, bearerToken) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path49) {
+    async get(path50) {
       let res;
       try {
-        res = await fetch(`${root}${path49}`, {
+        res = await fetch(`${root}${path50}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -10164,16 +10217,16 @@ function createHttpClient(baseUrl, bearerToken) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path49}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path50}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path49, body) {
+    async post(path50, body) {
       let res;
       try {
-        res = await fetch(`${root}${path49}`, {
+        res = await fetch(`${root}${path50}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -10187,7 +10240,7 @@ function createHttpClient(baseUrl, bearerToken) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path49}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path50}: ${text}`,
           text
         );
       }
@@ -10201,12 +10254,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path49 = projectPath(
+  const path50 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path49);
+    const result = await client.get(path50);
     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}.` : "");
@@ -10232,12 +10285,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path49 = projectPath(
+  const path50 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path49);
+    const result = await client.get(path50);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no downstream dependencies. Nothing else would break if it failed.`
@@ -10271,12 +10324,12 @@ function formatBlastEntry(n) {
 }
 async function runDependencies(client, input) {
   const depth = input.depth ?? 3;
-  const path49 = projectPath(
+  const path50 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path49);
+    const result = await client.get(path50);
     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}).`
@@ -10357,9 +10410,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path49 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
+  const path50 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
   try {
-    const body = await client.get(path49);
+    const body = await client.get(path50);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -10649,7 +10702,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_path47.default.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${import_node_path48.default.sep}`)) {
       return entry2;
     }
   }
@@ -10800,8 +10853,24 @@ async function runSync(opts) {
 // src/cli.ts
 var import_types27 = require("@neat.is/types");
+function isNpxInvocation() {
+  if (process.env.npm_command === "exec") return true;
+  const execpath = process.env.npm_execpath ?? "";
+  if (execpath.includes("npx")) return true;
+  const entry2 = process.argv[1] ?? "";
+  if (entry2.includes("/_npx/") || entry2.includes("\\_npx\\")) return true;
+  return false;
+}
+function commandPrefix() {
+  return isNpxInvocation() ? "npx neat.is" : "neat";
+}
 function usage() {
-  console.log("usage: neat <command> [args] [--project <name>]");
+  const neat = commandPrefix();
+  console.log("Installed via npx? Prefix commands with `npx neat.is`, or install once: `npm i -g neat.is`.");
+  console.log("");
+  console.log(`usage: ${neat} <command> [args] [--project <name>]`);
+  console.log("");
+  console.log(`Run \`${neat}\` with no command from inside your project to go zero-to-graph in one step.`);
   console.log("");
   console.log("lifecycle commands:");
   console.log("  init <path>    One-time install: discover, extract, register, plan SDK install.");
@@ -10841,30 +10910,30 @@ function usage() {
   console.log("");
   console.log("query commands (mirror the MCP tools, ADR-050):");
   console.log("  root-cause <node-id>             Walk inbound edges to find what broke first.");
-  console.log("                                   example: neat root-cause service:<name>");
+  console.log(`                                   example: ${neat} root-cause service:<name>`);
   console.log("  blast-radius <node-id>           BFS outbound \u2014 what would break if this dies.");
-  console.log("                                   example: neat blast-radius database:<host>");
+  console.log(`                                   example: ${neat} blast-radius database:<host>`);
   console.log("  dependencies <node-id>           Transitive outbound dependencies.");
   console.log("                                   Flags: --depth N (default 3, max 10)");
-  console.log("                                   example: neat dependencies service:<name> --depth 2");
+  console.log(`                                   example: ${neat} dependencies service:<name> --depth 2`);
   console.log("  observed-dependencies <node-id>  OBSERVED-only outbound edges (runtime traffic).");
-  console.log("                                   example: neat observed-dependencies service:<name>");
+  console.log(`                                   example: ${neat} observed-dependencies service:<name>`);
   console.log("  incidents [<node-id>]            Recent error events; per-node when an id is given.");
   console.log("                                   Flags: --limit N (default 20)");
-  console.log("                                   example: neat incidents service:<name> --limit 5");
+  console.log(`                                   example: ${neat} incidents service:<name> --limit 5`);
   console.log("  search <query>                   Semantic (or substring) match on node names/ids.");
-  console.log('                                   example: neat search "checkout"');
+  console.log(`                                   example: ${neat} search "checkout"`);
   console.log("  diff --against <snapshot>        Compare the live graph to a saved snapshot.");
-  console.log("                                   example: neat diff --against ./snapshots/baseline.json");
+  console.log(`                                   example: ${neat} diff --against ./snapshots/baseline.json`);
   console.log("  stale-edges                      Recent OBSERVED \u2192 STALE transitions.");
   console.log("                                   Flags: --limit N, --edge-type CALLS|CONNECTS_TO|...");
-  console.log("                                   example: neat stale-edges --edge-type CALLS");
+  console.log(`                                   example: ${neat} stale-edges --edge-type CALLS`);
   console.log("  policies                         Current policy violations.");
   console.log("                                   Flags: --node <id>, --hypothetical-action <json>");
-  console.log("                                   example: neat policies --node service:<name> --json");
+  console.log(`                                   example: ${neat} policies --node service:<name> --json`);
   console.log("  divergences                      Where code (EXTRACTED) and production (OBSERVED) disagree.");
   console.log("                                   Flags: --type <list>, --min-confidence <0..1>, --node <id>");
-  console.log("                                   example: neat divergences --min-confidence 0.7");
+  console.log(`                                   example: ${neat} divergences --min-confidence 0.7`);
   console.log("");
   console.log("flags:");
   console.log('  --project <name>   Name the project this command targets. Default: "default".');
@@ -11008,40 +11077,10 @@ function assignFlag(out, field, value) {
   ;
   out[field] = value;
 }
-function readPackageVersion() {
-  const here = typeof __dirname !== "undefined" ? __dirname : import_node_path48.default.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
-  const candidates = [
-    import_node_path48.default.resolve(here, "../package.json"),
-    import_node_path48.default.resolve(here, "../../package.json")
-  ];
-  for (const candidate of candidates) {
-    try {
-      const raw = (0, import_node_fs31.readFileSync)(candidate, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed.name === "@neat.is/core" && typeof parsed.version === "string") {
-        return parsed.version;
-      }
-    } catch {
-    }
-  }
-  return "unknown";
-}
 function printVersion() {
   process.stdout.write(`${readPackageVersion()}
 `);
 }
-function printBanner() {
-  console.log("\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557");
-  console.log("\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D");
-  console.log("\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   ");
-  console.log("\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   ");
-  console.log("\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   ");
-  console.log("\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   ");
-  console.log("");
-  console.log("  Network Expressive Architecting Tool");
-  console.log(`  neat.is  \xB7  v${readPackageVersion()}  \xB7  Apache 2.0`);
-  console.log("");
-}
 function printDiscoveryReport(opts, services) {
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
   const mode = opts.dryRun ? "dry-run" : opts.apply ? "apply" : "patch-only";
@@ -11080,7 +11119,7 @@ async function buildPatchSections(services, project) {
 }
 async function runInit(opts) {
   const written = [];
-  const stat = await import_node_fs31.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs32.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 };
@@ -11089,13 +11128,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_path48.default.join(opts.scanPath, "neat.patch");
+  const patchPath = import_node_path49.default.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
-    await import_node_fs31.promises.writeFile(patchPath, patch, "utf8");
+    await import_node_fs32.promises.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = import_node_path48.default.join(opts.scanPath, ".gitignore");
-    const gitignoreExists = await import_node_fs31.promises.stat(gitignorePath).then(() => true).catch(() => false);
+    const gitignorePath = import_node_path49.default.join(opts.scanPath, ".gitignore");
+    const gitignoreExists = await import_node_fs32.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.");
@@ -11106,9 +11145,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    import_node_path48.default.join(opts.scanPath, "neat-out")
+    import_node_path49.default.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = import_node_path48.default.join(import_node_path48.default.dirname(opts.outPath), import_node_path48.default.basename(projectPaths.errorsPath));
+  const errorsPath = import_node_path49.default.join(import_node_path49.default.dirname(opts.outPath), import_node_path49.default.basename(projectPaths.errorsPath));
   const result = await extractFromDirectory(graph, opts.scanPath, { errorsPath });
   await saveGraphToDisk(graph, opts.outPath);
   written.push(opts.outPath);
@@ -11187,7 +11226,7 @@ async function runInit(opts) {
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
-      await import_node_fs31.promises.writeFile(patchPath, patch, "utf8");
+      await import_node_fs32.promises.writeFile(patchPath, patch, "utf8");
       written.push(patchPath);
     }
   }
@@ -11227,9 +11266,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return import_node_path48.default.resolve(override);
+  if (override && override.length > 0) return import_node_path49.default.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path48.default.join(home, ".claude.json");
+  return import_node_path49.default.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet2 = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -11241,7 +11280,7 @@ async function runSkill(opts) {
     const target = claudeConfigPath();
     let existing = {};
     try {
-      existing = JSON.parse(await import_node_fs31.promises.readFile(target, "utf8"));
+      existing = JSON.parse(await import_node_fs32.promises.readFile(target, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
@@ -11253,8 +11292,8 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await import_node_fs31.promises.mkdir(import_node_path48.default.dirname(target), { recursive: true });
-    await import_node_fs31.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    await import_node_fs32.promises.mkdir(import_node_path49.default.dirname(target), { recursive: true });
+    await import_node_fs32.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
     console.log(`neat skill: wrote mcpServers.neat to ${target}`);
     console.log("restart Claude Code to pick up the new MCP server.");
     return { exitCode: 0 };
@@ -11269,16 +11308,24 @@ async function runSkill(opts) {
   return { exitCode: 0 };
 }
 async function main() {
-  const [, , cmd, ...rest] = process.argv;
-  if (!cmd || cmd === "-h" || cmd === "--help") {
+  const argv = process.argv.slice(2);
+  const cmd0 = argv[0];
+  if (cmd0 === "-h" || cmd0 === "--help") {
     usage();
     process.exit(0);
   }
-  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+  if (cmd0 === "--version" || cmd0 === "-v" || cmd0 === "version") {
     printVersion();
     process.exit(0);
   }
-  const parsed = parseArgs(rest);
+  const argvParsed = parseArgs(argv);
+  if (argvParsed.positional.length === 0) {
+    const orchestratorCode2 = await tryOrchestrator(process.cwd(), argvParsed);
+    if (orchestratorCode2 !== null && orchestratorCode2 !== 0) process.exit(orchestratorCode2);
+    return;
+  }
+  const cmd = argvParsed.positional[0];
+  const parsed = { ...argvParsed, positional: argvParsed.positional.slice(1) };
   const { positional, apply: apply3, dryRun, noInstall } = parsed;
   const project = parsed.project ?? DEFAULT_PROJECT;
   if (cmd === "init") {
@@ -11292,12 +11339,12 @@ async function main() {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = import_node_path48.default.resolve(target);
+    const scanPath = import_node_path49.default.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : import_node_path48.default.basename(scanPath);
+    const projectName = projectExplicit ? project : import_node_path49.default.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, import_node_path48.default.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = import_node_path48.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const fallback = pathsForProject(projectKey, import_node_path49.default.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = import_node_path49.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
     const result = await runInit({
       scanPath,
       outPath,
@@ -11318,21 +11365,21 @@ async function main() {
       usage();
       process.exit(2);
     }
-    const scanPath = import_node_path48.default.resolve(target);
-    const stat = await import_node_fs31.promises.stat(scanPath).catch(() => null);
+    const scanPath = import_node_path49.default.resolve(target);
+    const stat = await import_node_fs32.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_path48.default.join(scanPath, "neat-out"));
-    const outPath = import_node_path48.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = import_node_path48.default.resolve(
-      process.env.NEAT_ERRORS_PATH ?? import_node_path48.default.join(import_node_path48.default.dirname(outPath), import_node_path48.default.basename(projectPaths.errorsPath))
+    const projectPaths = pathsForProject(project, import_node_path49.default.join(scanPath, "neat-out"));
+    const outPath = import_node_path49.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = import_node_path49.default.resolve(
+      process.env.NEAT_ERRORS_PATH ?? import_node_path49.default.join(import_node_path49.default.dirname(outPath), import_node_path49.default.basename(projectPaths.errorsPath))
     );
-    const staleEventsPath = import_node_path48.default.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path48.default.join(import_node_path48.default.dirname(outPath), import_node_path48.default.basename(projectPaths.staleEventsPath))
+    const staleEventsPath = import_node_path49.default.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path49.default.join(import_node_path49.default.dirname(outPath), import_node_path49.default.basename(projectPaths.staleEventsPath))
     );
-    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path48.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path49.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
     const handle = await startWatch(getGraph(project), {
       scanPath,
       outPath,
@@ -11478,11 +11525,11 @@ async function main() {
   process.exit(1);
 }
 async function tryOrchestrator(cmd, parsed) {
-  const scanPath = import_node_path48.default.resolve(cmd);
-  const stat = await import_node_fs31.promises.stat(scanPath).catch(() => null);
+  const scanPath = import_node_path49.default.resolve(cmd);
+  const stat = await import_node_fs32.promises.stat(scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) return null;
   const projectExplicit = parsed.project !== null;
-  const projectName = projectExplicit ? parsed.project : import_node_path48.default.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : import_node_path49.default.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,
@@ -11683,11 +11730,15 @@ if (/[\\/]cli\.(?:cjs|js)$/.test(entry) || entry.endsWith("/cli") || entry.endsW
 0 && (module.exports = {
   CLAUDE_SKILL_CONFIG,
   QUERY_VERBS,
+  commandPrefix,
+  isNpxInvocation,
+  main,
   parseArgs,
   printBanner,
   readPackageVersion,
   runInit,
   runQueryVerb,
-  runSkill
+  runSkill,
+  usage
 });
 //# sourceMappingURL=cli.cjs.map