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

package/dist/{chunk-KTJK2PAH.js → chunk-H2BAPN33.js}

@@ -1,10 +1,15 @@
+import {
+  findDaemonByProject,
+  getProject,
+  listProjects
+} from "./chunk-RGYC5U2Q.js";
 import {
   BEARER_DELEGATED,
   columnsFromSqlStatement,
   mountBearerAuth,
   readAuthEnv,
   tableFromSqlStatement
-} from "./chunk-EFBWQIKG.js";
+} from "./chunk-QPG2QXCW.js";
 
 // src/graph.ts
 import GraphDefault from "graphology";
@@ -2036,8 +2041,8 @@ function chiRoutesFromSource(source, parser) {
   chiWalk(tree.rootNode, "", out);
   return out;
 }
-function stripChiRegex(path77) {
-  return path77.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
+function stripChiRegex(path76) {
+  return path76.replace(/\{([^{}:]+):[^{}]*\}/g, "{$1}");
 }
 function chiWalk(node, prefix, out) {
   for (let i = 0; i < node.namedChildCount; i++) {
@@ -2709,9 +2714,9 @@ function rubyRocketRoute(args) {
     if (!pair || pair.type !== "pair") continue;
     const k = pair.childForFieldName("key");
     if (k?.type !== "string") continue;
-    const path77 = rubyLiteral(k);
-    if (path77 === null) continue;
-    return { path: path77, target: rubyLiteral(pair.childForFieldName("value")) };
+    const path76 = rubyLiteral(k);
+    if (path76 === null) continue;
+    return { path: path76, target: rubyLiteral(pair.childForFieldName("value")) };
   }
   return null;
 }
@@ -4658,7 +4663,29 @@ function ensureFrontierNode(graph, host, ts) {
   graph.addNode(id, node);
   return id;
 }
-function upsertObservedEdge(graph, type, source, target, ts, isError = false, evidence, durationMs) {
+var EDGE_ERROR_MESSAGE_MAX = 512;
+function buildEdgeErrorExemplar(detail, ts) {
+  return {
+    ...detail.exceptionType !== void 0 ? { exceptionType: detail.exceptionType } : {},
+    ...detail.message !== void 0 ? { message: detail.message.slice(0, EDGE_ERROR_MESSAGE_MAX) } : {},
+    ...detail.httpStatusCode !== void 0 ? { httpStatusCode: detail.httpStatusCode } : {},
+    at: ts
+  };
+}
+function edgeErrorDetailFromSpan(span) {
+  const exceptionType = span.exception?.type;
+  const message = span.exception?.message;
+  const httpStatusCode = httpResponseStatus(span);
+  if (exceptionType === void 0 && message === void 0 && httpStatusCode === void 0) {
+    return void 0;
+  }
+  return {
+    ...exceptionType !== void 0 ? { exceptionType } : {},
+    ...message !== void 0 ? { message } : {},
+    ...httpStatusCode !== void 0 ? { httpStatusCode } : {}
+  };
+}
+function upsertObservedEdge(graph, type, source, target, ts, isError = false, evidence, durationMs, errorDetail) {
   if (!graph.hasNode(source) || !graph.hasNode(target)) return null;
   const grain = source.startsWith("file:") || source.startsWith("symbol:") ? "file" : "service";
   const id = makeObservedEdgeId(type, source, target);
@@ -4668,13 +4695,15 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
     const newErrorCount = (existing.signal?.errorCount ?? 0) + (isError ? 1 : 0);
     const latencyHist2 = durationMs !== void 0 ? recordLatency({ ...existing.signal?.latencyHist ?? {} }, durationMs) : existing.signal?.latencyHist;
     const latencyMs2 = latencyPercentiles(latencyHist2) ?? existing.signal?.latencyMs;
+    const lastError2 = isError && errorDetail ? buildEdgeErrorExemplar(errorDetail, ts) : existing.signal?.lastError;
     const newSignal = {
       spanCount: newSpanCount,
       errorCount: newErrorCount,
       lastObservedAgeMs: 0,
       ...latencyHist2 ? { latencyHist: latencyHist2 } : {},
       ...latencyMs2 ? { latencyMs: latencyMs2 } : {},
-      ...existing.signal?.anomalous !== void 0 ? { anomalous: existing.signal.anomalous } : {}
+      ...existing.signal?.anomalous !== void 0 ? { anomalous: existing.signal.anomalous } : {},
+      ...lastError2 ? { lastError: lastError2 } : {}
     };
     const updated = {
       ...existing,
@@ -4691,12 +4720,14 @@ function upsertObservedEdge(graph, type, source, target, ts, isError = false, ev
   }
   const latencyHist = durationMs !== void 0 ? recordLatency({}, durationMs) : void 0;
   const latencyMs = latencyHist ? latencyPercentiles(latencyHist) : void 0;
+  const lastError = isError && errorDetail ? buildEdgeErrorExemplar(errorDetail, ts) : void 0;
   const signal = {
     spanCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedAgeMs: 0,
     ...latencyHist ? { latencyHist } : {},
-    ...latencyMs ? { latencyMs } : {}
+    ...latencyMs ? { latencyMs } : {},
+    ...lastError ? { lastError } : {}
   };
   const edge = {
     id,
@@ -5037,6 +5068,7 @@ async function handleSpan(ctx, span) {
   const sourceId = ensureServiceNode(ctx.graph, span.service, env);
   const isError = spanRecordsError(span);
   const durationMs = span.durationNanos > 0n && !spanIsStreaming(span) ? Number(span.durationNanos) / 1e6 : void 0;
+  const errorDetail = isError ? edgeErrorDetailFromSpan(span) : void 0;
   const sourceServiceNode = ctx.graph.getNodeAttributes(sourceId);
   const callSite = callSiteFromSpan(span, sourceServiceNode, ctx.scanPath);
   cacheSpanService(span, nowMs, callSite);
@@ -5076,7 +5108,8 @@ async function handleSpan(ctx, span) {
         ts,
         isError,
         callSiteEvidence,
-        durationMs
+        durationMs,
+        errorDetail
       );
       if (result) affectedNode = targetId;
       if (span.dbSystem === "mongodb" && span.dbCollection) {
@@ -5089,7 +5122,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
       }
       if (span.dbTable) {
@@ -5102,7 +5136,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
         mergeObservedColumns(ctx.graph, tableId, span.dbColumns);
       }
@@ -5122,7 +5157,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else if (span.graphqlOperationName && span.graphqlOperationType && spanServesGraphqlOperation(span.kind)) {
@@ -5140,7 +5176,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else if (span.rpcSystem === "grpc" && span.rpcService && span.rpcMethod && spanServesGrpcMethod(span.kind)) {
@@ -5153,7 +5190,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else if (span.websocketChannel && spanServesWebsocketChannel(span.kind)) {
@@ -5170,7 +5208,8 @@ async function handleSpan(ctx, span) {
       ts,
       isError,
       callSiteEvidence,
-      durationMs
+      durationMs,
+      errorDetail
     );
     if (result) affectedNode = targetId;
   } else {
@@ -5187,7 +5226,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
         affectedNode = targetId;
         resolvedViaAddress = true;
@@ -5201,7 +5241,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           callSiteEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
         affectedNode = frontierNodeId;
         resolvedViaAddress = true;
@@ -5228,7 +5269,8 @@ async function handleSpan(ctx, span) {
           ts,
           isError,
           fallbackEvidence,
-          durationMs
+          durationMs,
+          errorDetail
         );
       }
     }
@@ -5243,7 +5285,7 @@ async function handleSpan(ctx, span) {
     );
     if (routeNodeId) {
       const routeSvc = ctx.graph.getNodeAttributes(routeNodeId).service;
-      upsertObservedEdge(ctx.graph, EdgeType5.CONTAINS, serviceId(routeSvc), routeNodeId, ts, isError, void 0, durationMs);
+      upsertObservedEdge(ctx.graph, EdgeType5.CONTAINS, serviceId(routeSvc), routeNodeId, ts, isError, void 0, durationMs, errorDetail);
     }
   }
   if (span.statusCode === 2) {
@@ -5726,19 +5768,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, path77, edges) {
-    if (path77.length > best.path.length) {
-      best = { path: [...path77], edges: [...edges] };
+  function step(node, path76, edges) {
+    if (path76.length > best.path.length) {
+      best = { path: [...path76], edges: [...edges] };
     }
-    if (path77.length - 1 >= maxDepth) return;
+    if (path76.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);
-      path77.push(srcId);
+      path76.push(srcId);
       edges.push(edge);
-      step(srcId, path77, edges);
-      path77.pop();
+      step(srcId, path76, edges);
+      path76.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -5953,20 +5995,20 @@ function dominantFailingCall(graph, serviceId17, visited) {
   return best;
 }
 function followFailingCallChain(graph, originServiceId, maxDepth) {
-  const path77 = [originServiceId];
+  const path76 = [originServiceId];
   const edges = [];
   const visited = /* @__PURE__ */ new Set([originServiceId]);
   let current = originServiceId;
   for (let depth = 0; depth < maxDepth; depth++) {
     const hop = dominantFailingCall(graph, current, visited);
     if (!hop) break;
-    path77.push(hop.nextService);
+    path76.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path77, edges, culprit: current };
+  return { path: path76, edges, culprit: current };
 }
 function isStaleCallEdge(e) {
   return e.type === EdgeType6.CALLS && e.provenance === Provenance6.STALE;
@@ -6002,26 +6044,26 @@ function dominantStaleCall(graph, serviceId17, visited) {
   return best;
 }
 function followStaleCallChain(graph, originServiceId, maxDepth) {
-  const path77 = [originServiceId];
+  const path76 = [originServiceId];
   const edges = [];
   const visited = /* @__PURE__ */ new Set([originServiceId]);
   let current = originServiceId;
   for (let depth = 0; depth < maxDepth; depth++) {
     const hop = dominantStaleCall(graph, current, visited);
     if (!hop) break;
-    path77.push(hop.nextService);
+    path76.push(hop.nextService);
     edges.push(hop.edge);
     visited.add(hop.nextService);
     current = hop.nextService;
   }
   if (edges.length === 0) return null;
-  return { path: path77, edges, culprit: current };
+  return { path: path76, edges, culprit: current };
 }
 function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   const chain = followFailingCallChain(graph, originId, ROOT_CAUSE_MAX_DEPTH);
   if (!chain) return null;
   const culprit = chain.culprit;
-  const path77 = [...chain.path];
+  const path76 = [...chain.path];
   const edgeProvenances = chain.edges.map((e) => e.provenance);
   const baseConfidence = confidenceFromMix(chain.edges);
   const confidence = Math.max(0, Math.min(1, baseConfidence * INCIDENT_ROOT_CAUSE_CONFIDENCE));
@@ -6029,14 +6071,14 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   if (loc) {
     let rootCauseNode = culprit;
     if (loc.fileNode) {
-      path77.push(loc.fileNode);
+      path76.push(loc.fileNode);
       edgeProvenances.push(Provenance6.OBSERVED);
       rootCauseNode = loc.fileNode;
     }
     return RootCauseResultSchema.parse({
       rootCauseNode,
       rootCauseReason: loc.rootCauseReason,
-      traversalPath: path77,
+      traversalPath: path76,
       edgeProvenances,
       confidence,
       ...loc.fixRecommendation ? { fixRecommendation: loc.fixRecommendation } : {}
@@ -6048,7 +6090,7 @@ function crossServiceRootCause(graph, originId, incidents, errorEvent) {
   return RootCauseResultSchema.parse({
     rootCauseNode: culprit,
     rootCauseReason: `${culpritName} is failing downstream calls (${errs} observed error${errs === 1 ? "" : "s"})`,
-    traversalPath: path77,
+    traversalPath: path76,
     edgeProvenances,
     confidence,
     fixRecommendation: `Inspect ${culpritName}'s failing handler`
@@ -6701,10 +6743,10 @@ function enrichWithNavigation(graph, errorNodeId, tagged, incidents, now) {
     traversalPath = staleChain.path;
     edgeProvenances = staleChain.edges.map((e) => e.provenance);
   } else if (top.node !== seedNode) {
-    const path77 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
-    if (path77) {
-      traversalPath = path77.nodes;
-      edgeProvenances = path77.edges.map((e) => e.provenance);
+    const path76 = findPath(graph, errorNodeId, top.node, "up", ROOT_CAUSE_MAX_DEPTH);
+    if (path76) {
+      traversalPath = path76.nodes;
+      edgeProvenances = path76.edges.map((e) => e.provenance);
     } else {
       traversalPath = [errorNodeId, top.node];
       edgeProvenances = [top.provenance ?? Provenance6.OBSERVED];
@@ -16320,6 +16362,11 @@ function detectObservedFailingEdge(graph, bucket) {
       spanCount,
       errorCount,
       errorRate: clampConfidence(errorRate),
+      // The bounded last-error exemplar rides the finding as evidence (ADR-236):
+      // the error rate says HOW MUCH is failing, the exemplar says WHAT failed —
+      // a timeout vs a deadlock vs a connection-refused, which `errorCount`
+      // alone cannot name. Present only when the observed edge carries one.
+      ...signal.lastError ? { lastError: signal.lastError } : {},
       confidence: OBSERVED_FAILING_CONFIDENCE,
       reason: `Code declares ${bucket.source} \u2192 ${bucket.target} (${bucket.type}) and production observes it, but ${errorCount}/${spanCount} observed calls fail (${pct}% error rate) \u2014 the declared dependency is predominantly failing. The declared intent (EXTRACTED) and the observed behaviour (OBSERVED) diverge.`,
       recommendation: "Treat this as a broken declared dependency, not a coverage gap: production runs the call the code declares and most calls error. Check the dependency\u2019s health, recent deploys, and the observed error responses on this edge."
@@ -16911,440 +16958,6 @@ function parseExtraProjects(raw) {
   return raw.split(",").map((p) => p.trim()).filter((p) => p.length > 0 && p !== DEFAULT_PROJECT);
 }
 
-// src/registry.ts
-import { promises as fs36 } from "fs";
-import os2 from "os";
-import path71 from "path";
-import {
-  RegistryFileSchema
-} from "@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 path71.resolve(override);
-  return path71.join(os2.homedir(), ".neat");
-}
-function registryPath() {
-  return path71.join(neatHome(), "projects.json");
-}
-function registryLockPath() {
-  return path71.join(neatHome(), "projects.json.lock");
-}
-function daemonPidPath() {
-  return path71.join(neatHome(), "neatd.pid");
-}
-function daemonsDir() {
-  return path71.join(neatHome(), "daemons");
-}
-function isFiniteInt(v) {
-  return typeof v === "number" && Number.isFinite(v);
-}
-function parseDaemonRecord(raw) {
-  let obj;
-  try {
-    obj = JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-  if (typeof obj !== "object" || obj === null) return void 0;
-  const r = obj;
-  const ports = r.ports;
-  if (typeof r.project !== "string" || typeof r.projectPath !== "string" || !isFiniteInt(r.pid) || r.status !== "running" && r.status !== "stopped" || typeof r.startedAt !== "string" || typeof r.neatVersion !== "string" || !ports || !isFiniteInt(ports.rest) || !isFiniteInt(ports.otlp) || !isFiniteInt(ports.web)) {
-    return void 0;
-  }
-  return {
-    project: r.project,
-    projectPath: r.projectPath,
-    pid: r.pid,
-    status: r.status,
-    ports: { rest: ports.rest, otlp: ports.otlp, web: ports.web },
-    startedAt: r.startedAt,
-    neatVersion: r.neatVersion
-  };
-}
-var defaultDiscoveryProbe = { isPidAlive: isPidAliveDefault };
-async function discoverDaemons(probe = defaultDiscoveryProbe) {
-  const dir = daemonsDir();
-  let names;
-  try {
-    names = await fs36.readdir(dir);
-  } catch (err) {
-    if (err.code === "ENOENT") return [];
-    throw err;
-  }
-  const out = [];
-  for (const name of names) {
-    if (!name.endsWith(".json")) continue;
-    const file = path71.join(dir, name);
-    let raw;
-    try {
-      raw = await fs36.readFile(file, "utf8");
-    } catch {
-      continue;
-    }
-    const record = parseDaemonRecord(raw);
-    if (!record) continue;
-    const live = record.status === "running" && probe.isPidAlive(record.pid);
-    out.push({ record, live, source: file });
-  }
-  out.sort((a, b) => a.record.project.localeCompare(b.record.project));
-  return out;
-}
-async function removeDaemonRecord(source) {
-  await fs36.unlink(source).catch(() => {
-  });
-}
-async function listMachineProjects(probe = defaultDiscoveryProbe) {
-  const discovered = await discoverDaemons(probe);
-  const byPath = /* @__PURE__ */ new Map();
-  for (const d of discovered) {
-    const key = await normalizeProjectPath(d.record.projectPath);
-    byPath.set(key, {
-      project: d.record.project,
-      projectPath: d.record.projectPath,
-      state: d.live ? "running" : "stopped",
-      ports: d.record.ports,
-      pid: d.record.pid
-    });
-  }
-  let legacy = [];
-  try {
-    legacy = (await readRegistry()).projects;
-  } catch {
-    legacy = [];
-  }
-  for (const entry of legacy) {
-    const key = await normalizeProjectPath(entry.path);
-    if (byPath.has(key)) continue;
-    byPath.set(key, {
-      project: entry.name,
-      projectPath: entry.path,
-      state: "registered",
-      registryStatus: entry.status
-    });
-  }
-  return [...byPath.values()].sort((a, b) => a.project.localeCompare(b.project));
-}
-async function findDaemonByProject(name, probe = defaultDiscoveryProbe) {
-  const discovered = await discoverDaemons(probe);
-  return discovered.find((d) => d.record.project === name);
-}
-function signalDaemonStop(pid) {
-  try {
-    process.kill(pid, "SIGTERM");
-    return true;
-  } catch (err) {
-    if (err.code === "ESRCH") return false;
-    throw err;
-  }
-}
-function isPidAliveDefault(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-async function readPidFile(file) {
-  try {
-    const raw = await fs36.readFile(file, "utf8");
-    const pid = Number.parseInt(raw.trim(), 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var defaultLockHolderProbe = {
-  isPidAlive: isPidAliveDefault,
-  daemonPidFromFile: () => readPidFile(daemonPidPath()),
-  async daemonResponds() {
-    const base = process.env.NEAT_API_URL ?? "http://localhost:8080";
-    try {
-      await fetch(`${base}/health`, { signal: AbortSignal.timeout(750) });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-async function readLockPid(lockPath) {
-  return readPidFile(lockPath);
-}
-async function classifyLockHolder(lockPath, probe = defaultLockHolderProbe) {
-  const lockPid = await readLockPid(lockPath);
-  const daemonPid = await probe.daemonPidFromFile();
-  if (lockPid !== void 0 && lockPid !== process.pid && probe.isPidAlive(lockPid)) {
-    return { kind: lockPid === daemonPid ? "daemon" : "command", pid: lockPid };
-  }
-  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // Guards against a stale pidfile whose PID got reused.
-  await probe.daemonResponds()) {
-    return { kind: "daemon", pid: daemonPid };
-  }
-  return { kind: "stale" };
-}
-function lockHolderMessage(holder, lockPath, timeoutMs) {
-  switch (holder.kind) {
-    case "daemon":
-      return `The neat daemon (pid ${holder.pid}) is holding the registry lock. Register this project through the daemon, or stop neatd and re-run \`neat init\`.`;
-    case "command":
-      return `Another neat command (pid ${holder.pid}) is holding the registry lock. Wait for it to finish, or check \`ps\` if you're not sure what's running.`;
-    case "stale":
-      return `timed out after ${timeoutMs}ms waiting for ${lockPath}. Another neat process is holding the lock; if no such process exists, remove the file by hand.`;
-  }
-}
-async function normalizeProjectPath(input) {
-  const resolved = path71.resolve(input);
-  try {
-    return await fs36.realpath(resolved);
-  } catch {
-    return resolved;
-  }
-}
-async function writeAtomically(target, contents) {
-  await fs36.mkdir(path71.dirname(target), { recursive: true });
-  const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await fs36.open(tmp, "w");
-  try {
-    await fd.writeFile(contents, "utf8");
-    await fd.sync();
-  } finally {
-    await fd.close();
-  }
-  await fs36.rename(tmp, target);
-}
-async function acquireLock(lockPath, timeoutMs = LOCK_TIMEOUT_MS, probe = defaultLockHolderProbe) {
-  const deadline = Date.now() + timeoutMs;
-  await fs36.mkdir(path71.dirname(lockPath), { recursive: true });
-  let probedHolder = false;
-  while (true) {
-    try {
-      const fd = await fs36.open(lockPath, "wx");
-      try {
-        await fd.writeFile(`${process.pid}
-`, "utf8");
-      } finally {
-        await fd.close();
-      }
-      return;
-    } catch (err) {
-      const code = err.code;
-      if (code !== "EEXIST") throw err;
-      if (!probedHolder) {
-        probedHolder = true;
-        const holder = await classifyLockHolder(lockPath, probe);
-        if (holder.kind === "daemon") {
-          throw new RegistryLockError(lockHolderMessage(holder, lockPath, timeoutMs));
-        }
-        if (holder.kind === "stale" && await isReclaimableLock(lockPath)) {
-          await fs36.unlink(lockPath).catch(() => {
-          });
-          continue;
-        }
-      }
-      if (Date.now() >= deadline) {
-        const holder = await classifyLockHolder(lockPath, probe);
-        throw new RegistryLockError(lockHolderMessage(holder, lockPath, timeoutMs));
-      }
-      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-    }
-  }
-}
-var LOCK_UNSTAMPED_GRACE_MS = 5e3;
-async function isReclaimableLock(lockPath) {
-  const pid = await readLockPid(lockPath);
-  if (pid !== void 0) return true;
-  try {
-    const stat = await fs36.stat(lockPath);
-    return Date.now() - stat.mtimeMs > LOCK_UNSTAMPED_GRACE_MS;
-  } catch {
-    return false;
-  }
-}
-async function releaseLock(lockPath) {
-  await fs36.unlink(lockPath).catch(() => {
-  });
-}
-async function withLock(fn) {
-  const lock = registryLockPath();
-  await acquireLock(lock);
-  try {
-    return await fn();
-  } finally {
-    await releaseLock(lock);
-  }
-}
-async function readRegistry() {
-  const file = registryPath();
-  let raw;
-  try {
-    raw = await fs36.readFile(file, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return { version: 1, projects: [] };
-    }
-    throw err;
-  }
-  const parsed = JSON.parse(raw);
-  return RegistryFileSchema.parse(parsed);
-}
-async function writeRegistry(reg) {
-  const validated = RegistryFileSchema.parse(reg);
-  await writeAtomically(registryPath(), JSON.stringify(validated, null, 2) + "\n");
-}
-var RegistryError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RegistryError";
-  }
-};
-var RegistryLockError = class extends RegistryError {
-  constructor(message) {
-    super(message);
-    this.name = "RegistryLockError";
-  }
-};
-var ProjectNameCollisionError = class extends RegistryError {
-  projectName;
-  constructor(name) {
-    super(`a project named "${name}" is already registered`);
-    this.name = "ProjectNameCollisionError";
-    this.projectName = name;
-  }
-};
-async function addProject(opts) {
-  const resolvedPath = await normalizeProjectPath(opts.path);
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const byName = reg.projects.find((p) => p.name === opts.name);
-    const byPath = reg.projects.find((p) => p.path === resolvedPath);
-    if (byName && byName.path !== resolvedPath) {
-      throw new ProjectNameCollisionError(opts.name);
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (byName && byName.path === resolvedPath) {
-      byName.lastSeenAt = now;
-      if (opts.languages) byName.languages = opts.languages;
-      if (opts.status) byName.status = opts.status;
-      await writeRegistry(reg);
-      return byName;
-    }
-    if (byPath && byPath.name !== opts.name) {
-      throw new ProjectNameCollisionError(byPath.name);
-    }
-    const entry = {
-      name: opts.name,
-      path: resolvedPath,
-      registeredAt: now,
-      languages: opts.languages ?? [],
-      status: opts.status ?? "active"
-    };
-    reg.projects.push(entry);
-    await writeRegistry(reg);
-    return entry;
-  });
-}
-async function getProject(name) {
-  const reg = await readRegistry();
-  return reg.projects.find((p) => p.name === name);
-}
-async function findProjectByPath(dir) {
-  const here = await normalizeProjectPath(dir);
-  const { projects } = await readRegistry();
-  let best;
-  for (const entry of projects) {
-    const inside = here === entry.path || here.startsWith(entry.path + path71.sep);
-    if (inside && (!best || entry.path.length > best.path.length)) best = entry;
-  }
-  return best;
-}
-async function listProjects() {
-  const reg = await readRegistry();
-  return reg.projects;
-}
-async function setStatus(name, status) {
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const entry = reg.projects.find((p) => p.name === name);
-    if (!entry) throw new RegistryError(`no project named "${name}"`);
-    entry.status = status;
-    await writeRegistry(reg);
-    return entry;
-  });
-}
-async function touchLastSeen(name, at = (/* @__PURE__ */ new Date()).toISOString()) {
-  await withLock(async () => {
-    const reg = await readRegistry();
-    const entry = reg.projects.find((p) => p.name === name);
-    if (!entry) return;
-    entry.lastSeenAt = at;
-    await writeRegistry(reg);
-  });
-}
-async function removeProject(name) {
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const idx = reg.projects.findIndex((p) => p.name === name);
-    if (idx < 0) return void 0;
-    const [removed] = reg.projects.splice(idx, 1);
-    await writeRegistry(reg);
-    return removed;
-  });
-}
-var DAY_MS2 = 24 * 60 * 60 * 1e3;
-var DEFAULT_PRUNE_TTL_MS = 7 * DAY_MS2;
-function pruneTtlMs() {
-  const raw = process.env.NEAT_REGISTRY_PRUNE_TTL_MS;
-  if (!raw) return DEFAULT_PRUNE_TTL_MS;
-  const n = Number.parseInt(raw, 10);
-  if (Number.isFinite(n) && n >= 0) return n;
-  console.warn(
-    `[neat] NEAT_REGISTRY_PRUNE_TTL_MS could not be parsed (${raw}); using default ${DEFAULT_PRUNE_TTL_MS}ms`
-  );
-  return DEFAULT_PRUNE_TTL_MS;
-}
-async function statPathStatus(p) {
-  try {
-    const stat = await fs36.stat(p);
-    return stat.isDirectory() ? "present" : "unknown";
-  } catch (err) {
-    return err.code === "ENOENT" ? "gone" : "unknown";
-  }
-}
-async function pruneRegistry(opts = {}) {
-  const ttlMs = opts.ttlMs ?? pruneTtlMs();
-  const statPath = opts.statPath ?? statPathStatus;
-  const now = opts.now ?? Date.now;
-  return withLock(async () => {
-    const reg = await readRegistry();
-    const removed = [];
-    const kept = [];
-    for (const entry of reg.projects) {
-      const status = await statPath(entry.path);
-      if (status !== "gone") {
-        kept.push(entry);
-        continue;
-      }
-      if (ttlMs <= 0) {
-        removed.push(entry);
-        continue;
-      }
-      const lastSeen = Date.parse(entry.lastSeenAt ?? entry.registeredAt);
-      const age = now() - (Number.isFinite(lastSeen) ? lastSeen : 0);
-      if (age > ttlMs) {
-        removed.push(entry);
-      } else {
-        kept.push(entry);
-      }
-    }
-    if (removed.length === 0) return [];
-    reg.projects = kept;
-    await writeRegistry(reg);
-    return removed;
-  });
-}
-
 // src/api.ts
 import Fastify from "fastify";
 import { timingSafeEqual } from "crypto";
@@ -17352,14 +16965,14 @@ import cors from "@fastify/cors";
 import { DivergenceTypeSchema, PoliciesCheckBodySchema, PolicySeveritySchema } from "@neat.is/types";
 
 // src/extend/index.ts
-import { promises as fs38 } from "fs";
-import path73 from "path";
-import os3 from "os";
+import { promises as fs37 } from "fs";
+import path72 from "path";
+import os2 from "os";
 import { resolve as registryResolve, list as registryList } from "@neat.is/instrumentation-registry";
 
 // src/installers/package-manager.ts
-import { promises as fs37 } from "fs";
-import path72 from "path";
+import { promises as fs36 } from "fs";
+import path71 from "path";
 import { spawn } from "child_process";
 var LOCKFILE_PRIORITY = [
   { lockfile: "bun.lockb", pm: "bun", args: ["install", "--no-summary"] },
@@ -17374,29 +16987,29 @@ var LOCKFILE_PRIORITY = [
 var NPM_FALLBACK_ARGS = ["install", "--no-audit", "--no-fund", "--prefer-offline"];
 async function exists2(p) {
   try {
-    await fs37.access(p);
+    await fs36.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(serviceDir) {
-  let dir = path72.resolve(serviceDir);
+  let dir = path71.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 = path72.join(dir, candidate.lockfile);
+      const lockPath = path71.join(dir, candidate.lockfile);
       if (await exists2(lockPath)) {
         return { pm: candidate.pm, cwd: dir, args: [...candidate.args] };
       }
     }
-    const parent = path72.dirname(dir);
+    const parent = path71.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return { pm: "npm", cwd: path72.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
+  return { pm: "npm", cwd: path71.resolve(serviceDir), args: [...NPM_FALLBACK_ARGS] };
 }
 async function runPackageManagerInstall(cmd) {
   return new Promise((resolve) => {
@@ -17438,15 +17051,15 @@ ${err.message}`
 // src/extend/index.ts
 async function fileExists2(p) {
   try {
-    await fs38.access(p);
+    await fs37.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function readPackageJson(scanPath) {
-  const pkgPath = path73.join(scanPath, "package.json");
-  const raw = await fs38.readFile(pkgPath, "utf8");
+  const pkgPath = path72.join(scanPath, "package.json");
+  const raw = await fs37.readFile(pkgPath, "utf8");
   return JSON.parse(raw);
 }
 var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -17460,15 +17073,15 @@ var HOOK_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([
 async function findHookFiles(scanPath) {
   const found = [];
   const walk11 = async (dir) => {
-    const entries = await fs38.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fs37.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || HOOK_WALK_SKIP_DIRS.has(entry.name)) continue;
-        await walk11(path73.join(dir, entry.name));
+        await walk11(path72.join(dir, entry.name));
       } else if (entry.isFile()) {
         if ((entry.name.startsWith("instrumentation") || entry.name.startsWith("otel-init")) && /\.(ts|js|cjs|mjs)$/.test(entry.name)) {
-          const rel = path73.relative(scanPath, path73.join(dir, entry.name));
-          found.push(rel.split(path73.sep).join("/"));
+          const rel = path72.relative(scanPath, path72.join(dir, entry.name));
+          found.push(rel.split(path72.sep).join("/"));
         }
       }
     }
@@ -17479,7 +17092,7 @@ async function findHookFiles(scanPath) {
 async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   let fallback = null;
   for (const file of hookFiles) {
-    const content = await fs38.readFile(path73.join(scanPath, file), "utf8");
+    const content = await fs37.readFile(path72.join(scanPath, file), "utf8");
     const patched = splicedContent(content, snippet2);
     if (patched !== null) return { file, content, patched };
     if (fallback === null) fallback = { file, content };
@@ -17487,12 +17100,12 @@ async function pickPrimaryHookFile(scanPath, hookFiles, snippet2) {
   return { file: fallback.file, content: fallback.content, patched: null };
 }
 function extendLogPath() {
-  return process.env.NEAT_EXTEND_LOG ?? path73.join(os3.homedir(), ".neat", "extend-log.ndjson");
+  return process.env.NEAT_EXTEND_LOG ?? path72.join(os2.homedir(), ".neat", "extend-log.ndjson");
 }
 async function appendExtendLog(entry) {
   const logPath = extendLogPath();
-  await fs38.mkdir(path73.dirname(logPath), { recursive: true });
-  await fs38.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
+  await fs37.mkdir(path72.dirname(logPath), { recursive: true });
+  await fs37.appendFile(logPath, JSON.stringify(entry) + "\n", "utf8");
 }
 function splicedContent(fileContent, snippet2) {
   if (fileContent.includes("__INSTRUMENTATION_BLOCK__")) {
@@ -17550,7 +17163,7 @@ function lookupInstrumentation(library, installedVersion) {
 }
 async function describeProjectInstrumentation(ctx) {
   const hookFiles = await findHookFiles(ctx.scanPath);
-  const envNeat = await fileExists2(path73.join(ctx.scanPath, ".env.neat"));
+  const envNeat = await fileExists2(path72.join(ctx.scanPath, ".env.neat"));
   const registryInstrPackages = new Set(
     registryList().map((e) => e.instrumentation_package).filter((p) => !!p)
   );
@@ -17572,7 +17185,7 @@ async function applyExtension(ctx, args, options) {
     );
   }
   for (const file of hookFiles) {
-    const content = await fs38.readFile(path73.join(ctx.scanPath, file), "utf8");
+    const content = await fs37.readFile(path72.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return { library: args.library, filesTouched: [], depsAdded: [], installOutput: "", alreadyApplied: true };
     }
@@ -17584,18 +17197,18 @@ async function applyExtension(ctx, args, options) {
     );
   }
   const primaryFile = primary.file;
-  const primaryPath = path73.join(ctx.scanPath, primaryFile);
+  const primaryPath = path72.join(ctx.scanPath, primaryFile);
   const filesTouched = [];
   const depsAdded = [];
-  const pkgPath = path73.join(ctx.scanPath, "package.json");
+  const pkgPath = path72.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 fs38.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    await fs37.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     filesTouched.push("package.json");
     depsAdded.push(`${args.instrumentation_package}@${args.version}`);
   }
-  await fs38.writeFile(primaryPath, primary.patched, "utf8");
+  await fs37.writeFile(primaryPath, primary.patched, "utf8");
   filesTouched.push(primaryFile);
   const cmd = await detectPackageManager(ctx.scanPath);
   const installer = options?.runInstall ?? runPackageManagerInstall;
@@ -17626,7 +17239,7 @@ async function dryRunExtension(ctx, args) {
     };
   }
   for (const file of hookFiles) {
-    const content = await fs38.readFile(path73.join(ctx.scanPath, file), "utf8");
+    const content = await fs37.readFile(path72.join(ctx.scanPath, file), "utf8");
     if (content.includes(args.registration_snippet)) {
       return {
         library: args.library,
@@ -17661,28 +17274,28 @@ async function rollbackExtension(ctx, args) {
   if (!await fileExists2(logPath)) {
     return { undone: false, message: "no apply found for library" };
   }
-  const raw = await fs38.readFile(logPath, "utf8");
+  const raw = await fs37.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 = path73.join(ctx.scanPath, "package.json");
+  const pkgPath = path72.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 fs38.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      await fs37.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
   }
   const hookFiles = await findHookFiles(ctx.scanPath);
   for (const file of hookFiles) {
-    const filePath = path73.join(ctx.scanPath, file);
-    const content = await fs38.readFile(filePath, "utf8");
+    const filePath = path72.join(ctx.scanPath, file);
+    const content = await fs37.readFile(filePath, "utf8");
     if (content.includes(match.registration_snippet)) {
       const filtered = content.split("\n").filter((line) => !line.includes(match.registration_snippet)).join("\n");
-      await fs38.writeFile(filePath, filtered, "utf8");
+      await fs37.writeFile(filePath, filtered, "utf8");
       break;
     }
   }
@@ -17761,10 +17374,11 @@ function locusOf(graph, ev) {
   const rawLine = ev.attributes?.[CODE_LINENO_ATTR2];
   const line = typeof rawLine === "number" ? rawLine : Number(rawLine);
   const node = graph.hasNode(ev.affectedNode) ? graph.getNodeAttributes(ev.affectedNode) : void 0;
+  const symbol = node?.type === "SymbolNode" ? node.qualname : void 0;
   return {
     file,
     ...Number.isFinite(line) ? { lineStart: line, lineEnd: line } : {},
-    ...node?.name ? { symbol: node.name } : {},
+    ...symbol ? { symbol } : {},
     service: node?.service ?? ev.service,
     provenance: Provenance26.OBSERVED
   };
@@ -17860,7 +17474,8 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
   const policyCards = applicable.map((p) => ({
     policyName: p.policyName,
     severity: p.severity,
-    message: p.reason
+    message: p.reason,
+    onViolation: p.onViolation
   }));
   const divergences = inGraph ? computeDivergences(graph, { node: affected, incidents }).divergences.map((d) => ({
     type: d.type,
@@ -17887,8 +17502,111 @@ function buildIncidentCard(graph, errorEvent, incidents, policies) {
     ...divergences.length > 0 ? { divergence: divergences } : {},
     headline: renderHeadline(graph, errorEvent, locus, rootCause?.node ?? null)
   };
+  card.grade = gradeIncidentCard(card);
   return IncidentCardSchema.parse(card);
 }
+var GRADE_PRIORS_VERSION = "sniper-architecture-priors-2026-10-08";
+var GRADE_WEIGHTS = {
+  evidence: 3,
+  locus: 2,
+  tests: 2,
+  reach: 1.5,
+  kind: 1.5,
+  chain: 1,
+  recur: 1,
+  div: 1
+};
+var PROVENANCE_WEIGHT = {
+  OBSERVED: 1,
+  EXTRACTED: 0.8,
+  INFERRED: 0.4,
+  FRONTIER: 0.3,
+  STALE: 0.2
+};
+var REACH_NODES_MAX = 50;
+var TIMEOUT = /timeout|timed out|deadline/i;
+var round2 = (n) => Math.round(n * 1e4) / 1e4;
+function factor(name, value, evidence, reason) {
+  return {
+    value: value === null ? null : round2(value),
+    weight: GRADE_WEIGHTS[name],
+    evidence,
+    ...reason ? { reason } : {}
+  };
+}
+function gradeIncidentCard(card) {
+  const rc = card.rootCause;
+  const chain = rc?.chain ?? [];
+  const gates = {
+    policyNotBlock: {
+      passed: !(card.policies ?? []).some((p) => p.onViolation === "block"),
+      evidence: ["policies[].onViolation"]
+    },
+    notSymptomOnly: {
+      passed: rc?.classification !== "symptom-only",
+      evidence: ["rootCause.classification"]
+    },
+    locusResolves: { passed: card.locus !== null, evidence: ["locus"] }
+  };
+  const gamma = Object.values(gates).every((g) => g.passed) ? 1 : 0;
+  const carrying = chain.some((h) => h.carriesSignal === true) ? chain.filter((h) => h.carriesSignal === true) : chain;
+  const hopWeights = carrying.map((h) => PROVENANCE_WEIGHT[h.provenance]);
+  const evidence = hopWeights.length === 0 ? factor("evidence", null, ["rootCause.chain[].provenance"], "no root-cause chain on the card") : hopWeights.some((w) => w === void 0) ? factor("evidence", null, ["rootCause.chain[].provenance"], "a chain hop has a provenance with no weight") : factor("evidence", Math.min(...hopWeights), ["rootCause.chain[].provenance"]);
+  const locus = card.locus ? factor("locus", card.locus.symbol ? 1 : 0.6, ["locus.symbol", "locus.file"]) : factor("locus", null, ["locus"], "no locus on the card (the locus gate fails)");
+  const tests = factor(
+    "tests",
+    null,
+    [],
+    "the card carries no test-file classification or test-to-symbol edges"
+  );
+  const reach = card.blastRadius ? factor(
+    "reach",
+    Math.max(0, 1 - card.blastRadius.totalAffected / REACH_NODES_MAX),
+    ["blastRadius.totalAffected"],
+    `nodes in the blast radius against a prior bound of ${REACH_NODES_MAX}`
+  ) : factor("reach", null, ["blastRadius"], "no blast radius on the card");
+  const timeout = TIMEOUT.test(`${card.exceptionType ?? ""} ${card.message}`);
+  const kindValue = timeout ? 0.3 : card.incidentKind === "exception" ? 1 : card.incidentKind === "5xx" || card.incidentKind === "status-error" ? 0.7 : card.incidentKind === "connector" ? 0.6 : 0.4;
+  const kind = factor("kind", kindValue, ["incidentKind", "exceptionType", "message"]);
+  const chainFactor = rc ? factor(
+    "chain",
+    1 / (1 + 0.25 * (Math.max(1, chain.length - 1) - 1)),
+    ["rootCause.chain"]
+  ) : factor("chain", null, ["rootCause"], "no root cause on the card");
+  const occurrences = card.count ?? 1;
+  const recurValue = Math.min(1, Math.log(1 + occurrences) / Math.log(11));
+  const recur = factor(
+    "recur",
+    recurValue,
+    ["count"],
+    card.count === void 0 ? "no coalesced count; one recorded occurrence" : void 0
+  );
+  const div = factor("div", (card.divergence ?? []).length > 0 ? 1 : 0.7, ["divergence"]);
+  const factors = { evidence, locus, tests, reach, kind, chain: chainFactor, recur, div };
+  let weighted = 0;
+  let total = 0;
+  for (const f of Object.values(factors)) {
+    if (f.value === null) continue;
+    weighted += f.weight * f.value;
+    total += f.weight;
+  }
+  const C = round2(weighted / total);
+  const G = round2(gamma * C);
+  const band = gamma === 0 || G < 0.5 ? "out" : G >= 0.75 ? "full" : "diagnose-only";
+  return {
+    G,
+    gamma,
+    gates,
+    C,
+    factors,
+    band,
+    urgency: {
+      value: null,
+      reason: "f_fresh needs the time of the last OBSERVED signal at the node, which the card does not carry"
+    },
+    priorsVersion: GRADE_PRIORS_VERSION
+  };
+}
 
 // src/ask.ts
 import { AskResultSchema, NodeType as NodeType32, Provenance as Provenance27, serviceId as serviceId15 } from "@neat.is/types";
@@ -18777,9 +18495,9 @@ data: ${JSON.stringify(envelope.payload)}
 
 // src/pr-verdict.ts
 import { createHash } from "crypto";
-import { promises as fs39 } from "fs";
-import os5 from "os";
-import path75 from "path";
+import { promises as fs38 } from "fs";
+import os4 from "os";
+import path74 from "path";
 
 // ../action/src/graph.mjs
 import { readFileSync as readFileSync3 } from "fs";
@@ -19054,8 +18772,8 @@ function renderVerdict({
 import { PrVerdictBodySchema } from "@neat.is/types";
 
 // src/connectors/hosted-repos.ts
-import os4 from "os";
-import path74 from "path";
+import os3 from "os";
+import path73 from "path";
 import { mkdtemp, rm } from "fs/promises";
 var CP_REQUEST_TIMEOUT_MS = 1e4;
 var DEFAULT_SYNC_INTERVAL_MS = 5 * 6e4;
@@ -19084,7 +18802,7 @@ async function cpPostStatus(deps, owner, name, body) {
   if (!res.ok && res.status !== 404) throw new Error(`control plane status POST \u2192 HTTP ${res.status}`);
 }
 var defaultCloneRepo = async (cloneUrl, ref, destDir) => {
-  const [{ default: git }, httpMod, fs41] = await Promise.all([
+  const [{ default: git }, httpMod, fs40] = await Promise.all([
     import("isomorphic-git"),
     import("isomorphic-git/http/node"),
     import("fs")
@@ -19095,7 +18813,7 @@ var defaultCloneRepo = async (cloneUrl, ref, destDir) => {
   const username = parsed.password ? parsed.username : "x-access-token";
   const cleanUrl = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
   const clone = git.clone({
-    fs: fs41,
+    fs: fs40,
     http,
     dir: destDir,
     url: cleanUrl,
@@ -19116,7 +18834,7 @@ var defaultCloneRepo = async (cloneUrl, ref, destDir) => {
   }
 };
 var defaultCloneCommit = async (cloneUrl, sha, destDir) => {
-  const [{ default: git }, httpMod, fs41] = await Promise.all([
+  const [{ default: git }, httpMod, fs40] = await Promise.all([
     import("isomorphic-git"),
     import("isomorphic-git/http/node"),
     import("fs")
@@ -19127,10 +18845,10 @@ var defaultCloneCommit = async (cloneUrl, sha, destDir) => {
   const username = parsed.password ? parsed.username : "x-access-token";
   const cleanUrl = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
   const clone = (async () => {
-    await git.init({ fs: fs41, dir: destDir });
-    await git.addRemote({ fs: fs41, dir: destDir, remote: "origin", url: cleanUrl });
+    await git.init({ fs: fs40, dir: destDir });
+    await git.addRemote({ fs: fs40, dir: destDir, remote: "origin", url: cleanUrl });
     await git.fetch({
-      fs: fs41,
+      fs: fs40,
       http,
       dir: destDir,
       remote: "origin",
@@ -19142,7 +18860,7 @@ var defaultCloneCommit = async (cloneUrl, sha, destDir) => {
       tags: false,
       ...password ? { onAuth: () => ({ username, password }) } : {}
     });
-    await git.checkout({ fs: fs41, dir: destDir, ref: sha, force: true });
+    await git.checkout({ fs: fs40, dir: destDir, ref: sha, force: true });
   })();
   clone.catch(() => {
   });
@@ -19167,10 +18885,10 @@ async function syncOneRepo(r, input) {
   const cloneRepo = input.cloneRepo ?? defaultCloneRepo;
   const extract = input.extract ?? extractFromDirectory;
   const label = `${r.owner}/${r.name}`;
-  const tmpRoot = input.tmpRoot ?? os4.tmpdir();
+  const tmpRoot = input.tmpRoot ?? os3.tmpdir();
   let dir;
   try {
-    dir = await mkdtemp(path74.join(tmpRoot, "neat-repo-"));
+    dir = await mkdtemp(path73.join(tmpRoot, "neat-repo-"));
     await cpPostStatus(deps, r.owner, r.name, { syncStatus: "syncing", detail: "cloning" }).catch(() => {
     });
     await cloneRepo(r.cloneUrl, r.defaultBranch, dir);
@@ -19339,9 +19057,9 @@ async function computePrVerdict(req, ctx, deps, deadline) {
   const startedAt = now();
   const cloneCommit = deps.cloneCommit ?? defaultCloneCommit;
   const extract = deps.extract ?? extractFromDirectory;
-  const root = await fs39.mkdtemp(path75.join(deps.tmpRoot ?? os5.tmpdir(), "neat-pr-"));
-  const baseDir = path75.join(root, "base");
-  const headDir = path75.join(root, "head");
+  const root = await fs38.mkdtemp(path74.join(deps.tmpRoot ?? os4.tmpdir(), "neat-pr-"));
+  const baseDir = path74.join(root, "base");
+  const headDir = path74.join(root, "head");
   const stage = async (name, run) => {
     const left = deadline - now();
     if (left <= 0) throw new PrVerdictError(`verdict ran out of time before ${name}`, 504, name);
@@ -19364,8 +19082,8 @@ async function computePrVerdict(req, ctx, deps, deadline) {
   };
   const extractOpts = { source: `${req.owner}/${req.name}`, announce: false };
   try {
-    await fs39.mkdir(baseDir);
-    await fs39.mkdir(headDir);
+    await fs38.mkdir(baseDir);
+    await fs38.mkdir(headDir);
     await stage("clone-base", () => cloneCommit(req.cloneUrl, req.baseSha, baseDir));
     await stage("clone-head", () => cloneCommit(req.cloneUrl, req.headSha, headDir));
     const baseGraph = makeGraph();
@@ -19387,7 +19105,7 @@ async function computePrVerdict(req, ctx, deps, deadline) {
       const found = observedBreakFrom(node, getObservedDependencies(ctx.liveGraph, node.id));
       if (found) observedBreaks.push(found);
     }
-    const { marker, body } = renderVerdict({
+    const { marker, body: rendered } = renderVerdict({
       graph: head,
       delta,
       changedFiles,
@@ -19395,6 +19113,7 @@ async function computePrVerdict(req, ctx, deps, deadline) {
       observedBreaks,
       tone: req.tone ?? "loud"
     });
+    const body = rendered.startsWith(marker) ? rendered.slice(marker.length).replace(/^(?:\r?\n)+/, "") : rendered;
     return {
       marker,
       body,
@@ -19406,7 +19125,7 @@ async function computePrVerdict(req, ctx, deps, deadline) {
       durationMs: now() - startedAt
     };
   } finally {
-    await fs39.rm(root, { recursive: true, force: true }).catch(() => {
+    await fs38.rm(root, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -19414,13 +19133,13 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "neat-out"]);
 async function hashTree(dir) {
   const out = /* @__PURE__ */ new Map();
   const walk11 = async (rel) => {
-    const entries = await fs39.readdir(path75.join(dir, rel), { withFileTypes: true }).catch(() => []);
+    const entries = await fs38.readdir(path74.join(dir, rel), { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       const child = rel ? `${rel}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) await walk11(child);
       } else if (entry.isFile()) {
-        const bytes = await fs39.readFile(path75.join(dir, child)).catch(() => null);
+        const bytes = await fs38.readFile(path74.join(dir, child)).catch(() => null);
         if (bytes) out.set(child, createHash("sha1").update(bytes).digest("hex"));
       }
     }
@@ -19437,9 +19156,9 @@ async function changedPathsBetween(baseDir, headDir) {
 }
 
 // src/connectors-config.ts
-import os6 from "os";
-import path76 from "path";
-import { promises as fs40 } from "fs";
+import os5 from "os";
+import path75 from "path";
+import { promises as fs39 } from "fs";
 var CONNECTORS_CONFIG_VERSION = 1;
 var EnvRefUnsetError = class extends Error {
   ref;
@@ -19451,19 +19170,19 @@ var EnvRefUnsetError = class extends Error {
     this.varName = varName;
   }
 };
-function neatHome2() {
+function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path76.resolve(override);
-  return path76.join(os6.homedir(), ".neat");
+  if (override && override.length > 0) return path75.resolve(override);
+  return path75.join(os5.homedir(), ".neat");
 }
-function connectorsConfigPath(home = neatHome2()) {
-  return path76.join(home, "connectors.json");
+function connectorsConfigPath(home = neatHome()) {
+  return path75.join(home, "connectors.json");
 }
 var MODE_MASK_LOOSER_THAN_0600 = 63;
 async function warnIfModeLooserThan0600(file) {
   if (process.platform === "win32") return;
   try {
-    const stat = await fs40.stat(file);
+    const stat = await fs39.stat(file);
     if ((stat.mode & MODE_MASK_LOOSER_THAN_0600) !== 0) {
       const mode = (stat.mode & 511).toString(8).padStart(3, "0");
       console.warn(
@@ -19473,11 +19192,11 @@ async function warnIfModeLooserThan0600(file) {
   } catch {
   }
 }
-async function readConnectorsConfig(home = neatHome2()) {
+async function readConnectorsConfig(home = neatHome()) {
   const file = connectorsConfigPath(home);
   let raw;
   try {
-    raw = await fs40.readFile(file, "utf8");
+    raw = await fs39.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { version: CONNECTORS_CONFIG_VERSION, connectors: [] };
@@ -19587,8 +19306,8 @@ function connectorMatchesProject(entry, project) {
 }
 var CONNECTORS_LOCK_TIMEOUT_MS = 5e3;
 var CONNECTORS_LOCK_RETRY_MS = 50;
-function connectorsConfigLockPath(home = neatHome2()) {
-  return path76.join(home, "connectors.json.lock");
+function connectorsConfigLockPath(home = neatHome()) {
+  return path75.join(home, "connectors.json.lock");
 }
 function isEnvRef(value) {
   return value.length > 1 && value.startsWith("$");
@@ -19601,9 +19320,9 @@ function redactCredentialRef(ref) {
   return out;
 }
 async function writeConfigAtomically0600(file, contents) {
-  await fs40.mkdir(path76.dirname(file), { recursive: true });
+  await fs39.mkdir(path75.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  const fd = await fs40.open(tmp, "w", 384);
+  const fd = await fs39.open(tmp, "w", 384);
   try {
     await fd.writeFile(contents, "utf8");
     await fd.chmod(384);
@@ -19611,14 +19330,14 @@ async function writeConfigAtomically0600(file, contents) {
   } finally {
     await fd.close();
   }
-  await fs40.rename(tmp, file);
+  await fs39.rename(tmp, file);
 }
 async function acquireConnectorsLock(lockPath, timeoutMs = CONNECTORS_LOCK_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
-  await fs40.mkdir(path76.dirname(lockPath), { recursive: true });
+  await fs39.mkdir(path75.dirname(lockPath), { recursive: true });
   for (; ; ) {
     try {
-      const fd = await fs40.open(lockPath, "wx");
+      const fd = await fs39.open(lockPath, "wx");
       try {
         await fd.writeFile(`${process.pid}
 `, "utf8");
@@ -19638,7 +19357,7 @@ async function acquireConnectorsLock(lockPath, timeoutMs = CONNECTORS_LOCK_TIMEO
   }
 }
 async function releaseConnectorsLock(lockPath) {
-  await fs40.unlink(lockPath).catch(() => {
+  await fs39.unlink(lockPath).catch(() => {
   });
 }
 async function withConnectorsLock(home, fn) {
@@ -19657,7 +19376,7 @@ function serializeConfig(config) {
     2
   ) + "\n";
 }
-async function upsertConnectorEntry(entry, home = neatHome2()) {
+async function upsertConnectorEntry(entry, home = neatHome()) {
   const file = connectorsConfigPath(home);
   return withConnectorsLock(home, async () => {
     const config = await readConnectorsConfig(home);
@@ -19670,7 +19389,7 @@ async function upsertConnectorEntry(entry, home = neatHome2()) {
     return { replaced };
   });
 }
-async function removeConnectorEntry(id, home = neatHome2()) {
+async function removeConnectorEntry(id, home = neatHome()) {
   const file = connectorsConfigPath(home);
   return withConnectorsLock(home, async () => {
     const config = await readConnectorsConfig(home);
@@ -20378,10 +20097,10 @@ var SUPABASE_RPC_TARGET_KIND = "supabase-rpc";
 // src/connectors/supabase/map.ts
 var REST_RPC_PATH_RE = /^\/rest\/v1\/rpc\/([^/?]+)/;
 var REST_TABLE_PATH_RE = /^\/rest\/v1\/([^/?]+)/;
-function targetFromRestPath(path77) {
-  const rpcMatch = REST_RPC_PATH_RE.exec(path77);
+function targetFromRestPath(path76) {
+  const rpcMatch = REST_RPC_PATH_RE.exec(path76);
   if (rpcMatch) return { targetKind: SUPABASE_RPC_TARGET_KIND, name: rpcMatch[1] };
-  const tableMatch = REST_TABLE_PATH_RE.exec(path77);
+  const tableMatch = REST_TABLE_PATH_RE.exec(path76);
   if (tableMatch) return { targetKind: SUPABASE_TABLE_TARGET_KIND, name: tableMatch[1] };
   return null;
 }
@@ -20976,9 +20695,9 @@ function parseFirebaseTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path77 = rest.slice(secondSep + 1);
-  if (!resourceName || !method || !path77) return null;
-  return { resourceName, method, path: path77 };
+  const path76 = rest.slice(secondSep + 1);
+  if (!resourceName || !method || !path76) return null;
+  return { resourceName, method, path: path76 };
 }
 function resourceNameFor(type, labels) {
   if (!labels) return null;
@@ -21016,14 +20735,14 @@ function mapLogEntryToSignal(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path77 = pathFromRequestUrl(req.requestUrl);
-  if (path77 === null) return null;
+  const path76 = pathFromRequestUrl(req.requestUrl);
+  if (path76 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD2;
   return {
     targetKind: resourceType,
-    targetName: packFirebaseTargetName({ resourceName, method, path: path77 }),
+    targetName: packFirebaseTargetName({ resourceName, method, path: path76 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21046,9 +20765,9 @@ import { NodeType as NodeType35 } from "@neat.is/types";
 function normalizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function inferServiceName(graph, resourceName, method, path77) {
+function inferServiceName(graph, resourceName, method, path76) {
   const wantedMethod = method.toUpperCase();
-  const wantedPath = normalizePathTemplate(path77);
+  const wantedPath = normalizePathTemplate(path76);
   const services = [];
   const owners = /* @__PURE__ */ new Set();
   graph.forEachNode((_id, attrs) => {
@@ -21256,7 +20975,7 @@ function mapEventToSignal(event) {
   if (Number.isNaN(observedAt.getTime())) return null;
   const statusCode = metadata?.statusCode;
   const isError = typeof statusCode === "number" && statusCode >= ERROR_STATUS_THRESHOLD3;
-  const path77 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
+  const path76 = metadata?.trigger ? parsePathFromTrigger(metadata.trigger) : void 0;
   return {
     targetKind: CLOUDFLARE_TARGET_KIND,
     targetName: scriptName,
@@ -21264,7 +20983,7 @@ function mapEventToSignal(event) {
     errorCount: isError ? 1 : 0,
     lastObservedIso: observedAt.toISOString(),
     method,
-    ...path77 ? { path: path77 } : {},
+    ...path76 ? { path: path76 } : {},
     ...typeof statusCode === "number" ? { statusCode } : {},
     ...typeof metadata?.duration === "number" ? { duration: metadata.duration } : {}
   };
@@ -21310,8 +21029,8 @@ function findTaggedWorkerFileNode(graph, workerName) {
   });
   return found;
 }
-function findMatchingRouteNode(graph, serviceName, method, path77) {
-  const normalizedPath = normalizePathTemplate(path77);
+function findMatchingRouteNode(graph, serviceName, method, path76) {
+  const normalizedPath = normalizePathTemplate(path76);
   let found = null;
   graph.forEachNode((id, attrs) => {
     if (found) return;
@@ -21328,10 +21047,10 @@ function createCloudflareResolveTarget(config, graph) {
   return (signal) => {
     if (signal.targetKind !== CLOUDFLARE_TARGET_KIND) return null;
     const scriptName = signal.targetName;
-    const { method, path: path77 } = signal;
+    const { method, path: path76 } = signal;
     const resolveRouteGrain = (serviceName, wholeFileId) => {
-      if (!method || !path77) return wholeFileId;
-      return findMatchingRouteNode(graph, serviceName, method, path77) ?? wholeFileId;
+      if (!method || !path76) return wholeFileId;
+      return findMatchingRouteNode(graph, serviceName, method, path76) ?? wholeFileId;
     };
     const mapping = config.workers?.[scriptName];
     if (mapping) {
@@ -21661,9 +21380,9 @@ function parseCloudRunTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP2);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path77 = rest.slice(secondSep + 1);
-  if (!serviceName || !method || !path77) return null;
-  return { serviceName, method, path: path77 };
+  const path76 = rest.slice(secondSep + 1);
+  if (!serviceName || !method || !path76) return null;
+  return { serviceName, method, path: path76 };
 }
 
 // src/connectors/cloud-run/map.ts
@@ -21692,14 +21411,14 @@ function mapLogEntryToSignal2(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path77 = pathFromRequestUrl2(req.requestUrl);
-  if (path77 === null) return null;
+  const path76 = pathFromRequestUrl2(req.requestUrl);
+  if (path76 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD4;
   return {
     targetKind: CLOUD_RUN_TARGET_KIND,
-    targetName: packCloudRunTargetName({ serviceName, method, path: path77 }),
+    targetName: packCloudRunTargetName({ serviceName, method, path: path76 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21737,14 +21456,14 @@ function createCloudRunResolveTarget(graph, config) {
     if (signal.targetKind !== CLOUD_RUN_TARGET_KIND) return null;
     const identity = parseCloudRunTargetName(signal.targetName);
     if (!identity) return null;
-    const { serviceName: gcpServiceName, method, path: path77 } = identity;
-    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path77) ?? void 0 : void 0);
+    const { serviceName: gcpServiceName, method, path: path76 } = identity;
+    const mappedService = config.serviceMap?.[gcpServiceName] ?? (config.inferServices ? inferServiceName(graph, gcpServiceName, method, path76) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode2(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path77)
+        normalizePathTemplate(path76)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: EdgeType32.CALLS };
@@ -21872,9 +21591,9 @@ function parseGcpLbTargetName(targetName) {
   const secondSep = rest.indexOf(FIELD_SEP3);
   if (secondSep === -1) return null;
   const method = rest.slice(0, secondSep);
-  const path77 = rest.slice(secondSep + 1);
-  if (!backendServiceName || !method || !path77) return null;
-  return { backendServiceName, method, path: path77 };
+  const path76 = rest.slice(secondSep + 1);
+  if (!backendServiceName || !method || !path76) return null;
+  return { backendServiceName, method, path: path76 };
 }
 
 // src/connectors/gcp-lb/map.ts
@@ -21903,14 +21622,14 @@ function mapLogEntryToSignal3(entry) {
   if (!req) return null;
   if (typeof req.requestMethod !== "string" || req.requestMethod.length === 0) return null;
   const method = req.requestMethod.toUpperCase();
-  const path77 = pathFromRequestUrl3(req.requestUrl);
-  if (path77 === null) return null;
+  const path76 = pathFromRequestUrl3(req.requestUrl);
+  if (path76 === null) return null;
   const timestamp = entry.timestamp;
   if (typeof timestamp !== "string" || timestamp.length === 0) return null;
   const isError = typeof req.status === "number" && req.status >= ERROR_STATUS_THRESHOLD5;
   return {
     targetKind: GCP_LB_TARGET_KIND,
-    targetName: packGcpLbTargetName({ backendServiceName, method, path: path77 }),
+    targetName: packGcpLbTargetName({ backendServiceName, method, path: path76 }),
     callCount: 1,
     errorCount: isError ? 1 : 0,
     lastObservedIso: timestamp
@@ -21948,14 +21667,14 @@ function createGcpLbResolveTarget(graph, config) {
     if (signal.targetKind !== GCP_LB_TARGET_KIND) return null;
     const identity = parseGcpLbTargetName(signal.targetName);
     if (!identity) return null;
-    const { backendServiceName, method, path: path77 } = identity;
-    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path77) ?? void 0 : void 0);
+    const { backendServiceName, method, path: path76 } = identity;
+    const mappedService = config.backendServiceMap?.[backendServiceName] ?? (config.inferServices ? inferServiceName(graph, backendServiceName, method, path76) ?? void 0 : void 0);
     if (mappedService) {
       const routeNodeId = findMatchingRouteNode3(
         graph,
         mappedService,
         method,
-        normalizePathTemplate(path77)
+        normalizePathTemplate(path76)
       );
       if (routeNodeId) {
         return { targetNodeId: routeNodeId, serviceName: mappedService, edgeType: EdgeType33.CALLS };
@@ -24416,25 +24135,6 @@ export {
   pathsForProject,
   Projects,
   parseExtraProjects,
-  registryPath,
-  registryLockPath,
-  removeDaemonRecord,
-  listMachineProjects,
-  findDaemonByProject,
-  signalDaemonStop,
-  normalizeProjectPath,
-  writeAtomically,
-  readRegistry,
-  RegistryError,
-  ProjectNameCollisionError,
-  addProject,
-  getProject,
-  findProjectByPath,
-  listProjects,
-  setStatus,
-  touchLastSeen,
-  removeProject,
-  pruneRegistry,
   maybeStartRepoSync,
   readConnectorsConfig,
   resolveCredential,
@@ -24457,4 +24157,4 @@ export {
   deprovisionConnector,
   buildApi
 };
-//# sourceMappingURL=chunk-KTJK2PAH.js.map
+//# sourceMappingURL=chunk-H2BAPN33.js.map