@neat.is/core 0.4.15 → 0.4.17

package/dist/server.cjs

@@ -56,9 +56,9 @@ function mountBearerAuth(app, opts) {
   const suffixes = [...DEFAULT_UNAUTH_SUFFIXES, ...opts.extraUnauthenticatedSuffixes ?? []];
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path42 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    const path43 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
     for (const suffix of suffixes) {
-      if (path42 === suffix || path42.endsWith(suffix)) {
+      if (path43 === suffix || path43.endsWith(suffix)) {
         done();
         return;
       }
@@ -186,8 +186,8 @@ function reshapeGrpcRequest(req) {
   };
 }
 function resolveProtoRoot() {
-  const here = import_node_path38.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return import_node_path38.default.resolve(here, "..", "proto");
+  const here = import_node_path39.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path39.default.resolve(here, "..", "proto");
 }
 function loadTraceService() {
   const protoRoot = resolveProtoRoot();
@@ -255,13 +255,13 @@ async function startOtelGrpcReceiver(opts) {
     })
   };
 }
-var import_node_url, import_node_path38, import_node_crypto2, grpc, protoLoader;
+var import_node_url, import_node_path39, 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_path38 = __toESM(require("path"), 1);
+    import_node_path39 = __toESM(require("path"), 1);
     import_node_crypto2 = require("crypto");
     grpc = __toESM(require("@grpc/grpc-js"), 1);
     protoLoader = __toESM(require("@grpc/proto-loader"), 1);
@@ -371,10 +371,10 @@ function parseOtlpRequest(body) {
   return out;
 }
 function loadProtoRoot() {
-  const here = import_node_path39.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  const protoRoot = import_node_path39.default.resolve(here, "..", "proto");
+  const here = import_node_path40.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  const protoRoot = import_node_path40.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
-  root.resolvePath = (_origin, target) => import_node_path39.default.resolve(protoRoot, target);
+  root.resolvePath = (_origin, target) => import_node_path40.default.resolve(protoRoot, target);
   root.loadSync(
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
@@ -570,12 +570,12 @@ async function buildOtelReceiver(opts) {
   };
   return decorated;
 }
-var import_node_path39, import_node_url2, import_fastify2, import_protobufjs, ENV_ATTR_CANONICAL, ENV_ATTR_COMPAT, ENV_FALLBACK, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
+var import_node_path40, import_node_url2, 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_path39 = __toESM(require("path"), 1);
+    import_node_path40 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
@@ -591,7 +591,7 @@ var init_otel = __esm({
 
 // src/server.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
 
 // src/graph.ts
 init_cjs_shims();
@@ -615,7 +615,7 @@ function getGraph(project = DEFAULT_PROJECT) {
 init_cjs_shims();
 var import_fastify = __toESM(require("fastify"), 1);
 var import_cors = __toESM(require("@fastify/cors"), 1);
-var import_types24 = require("@neat.is/types");
+var import_types25 = require("@neat.is/types");
 
 // src/extend/index.ts
 init_cjs_shims();
@@ -1358,19 +1358,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, path42, edges) {
-    if (path42.length > best.path.length) {
-      best = { path: [...path42], edges: [...edges] };
+  function step(node, path43, edges) {
+    if (path43.length > best.path.length) {
+      best = { path: [...path43], edges: [...edges] };
     }
-    if (path42.length - 1 >= maxDepth) return;
+    if (path43.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);
-      path42.push(srcId);
+      path43.push(srcId);
       edges.push(edge);
-      step(srcId, path42, edges);
-      path42.pop();
+      step(srcId, path43, edges);
+      path43.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -2174,6 +2174,41 @@ function thresholdForEdgeType(edgeType, overrides) {
   const map = overrides ?? loadStaleThresholdsFromEnv();
   return map[edgeType] ?? FALLBACK_STALE_THRESHOLD_MS;
 }
+var DEFAULT_INCIDENT_THRESHOLDS = {
+  threshold: 5,
+  windowMs: 6e4
+};
+function loadIncidentThresholdsFromEnv() {
+  const raw = process.env.NEAT_INCIDENT_THRESHOLDS;
+  if (!raw) return DEFAULT_INCIDENT_THRESHOLDS;
+  try {
+    const overrides = JSON.parse(raw);
+    const merged = { ...DEFAULT_INCIDENT_THRESHOLDS };
+    if (typeof overrides.threshold === "number" && Number.isFinite(overrides.threshold) && overrides.threshold >= 1) {
+      merged.threshold = Math.floor(overrides.threshold);
+    }
+    if (typeof overrides.windowMs === "number" && Number.isFinite(overrides.windowMs) && overrides.windowMs >= 0) {
+      merged.windowMs = overrides.windowMs;
+    }
+    return merged;
+  } catch (err) {
+    console.warn(
+      `[neat] NEAT_INCIDENT_THRESHOLDS could not be parsed (${err.message}); using defaults`
+    );
+    return DEFAULT_INCIDENT_THRESHOLDS;
+  }
+}
+function httpResponseStatus(span) {
+  for (const key of ["http.response.status_code", "http.status_code"]) {
+    const v = span.attributes[key];
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+    if (typeof v === "string") {
+      const n = Number(v);
+      if (Number.isFinite(n)) return n;
+    }
+  }
+  return void 0;
+}
 function nowIso(ctx) {
   return new Date(ctx.now ? ctx.now() : Date.now()).toISOString();
 }
@@ -2562,6 +2597,71 @@ function sanitizeAttributes(attrs) {
   }
   return out;
 }
+async function recordFailingResponseIncident(ctx, span, affectedNode, timestamp, statusCode, count, firstTimestamp) {
+  const attrs = sanitizeAttributes(span.attributes);
+  const first = firstTimestamp ?? timestamp;
+  const peer = pickAddress(span);
+  const message = count > 1 ? `${count} consecutive HTTP ${statusCode} responses` + (peer ? ` to ${peer}` : "") : `HTTP ${statusCode} response` + (peer ? ` from ${peer}` : "");
+  const ev = {
+    id: `${span.traceId}:${span.spanId}`,
+    timestamp,
+    service: span.service,
+    traceId: span.traceId,
+    spanId: span.spanId,
+    errorType: "http-failure",
+    errorMessage: message,
+    ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
+    affectedNode,
+    httpStatusCode: statusCode,
+    incidentCount: count,
+    firstTimestamp: first,
+    lastTimestamp: timestamp
+  };
+  await appendErrorEvent(ctx, ev);
+}
+async function advance4xxBurst(ctx, span, affectedNode, ts, nowMs, status2) {
+  const { threshold, windowMs } = loadIncidentThresholdsFromEnv();
+  if (!ctx.burstState) ctx.burstState = /* @__PURE__ */ new Map();
+  const peer = pickAddress(span) ?? span.spanId;
+  const key = `${span.service}->${peer}`;
+  const existing = ctx.burstState.get(key);
+  let state;
+  if (existing && nowMs - existing.lastMs <= windowMs) {
+    existing.count += 1;
+    existing.lastTs = ts;
+    existing.lastMs = nowMs;
+    existing.codes.set(status2, (existing.codes.get(status2) ?? 0) + 1);
+    state = existing;
+  } else {
+    state = {
+      count: 1,
+      firstTs: ts,
+      lastTs: ts,
+      lastMs: nowMs,
+      codes: /* @__PURE__ */ new Map([[status2, 1]])
+    };
+    ctx.burstState.set(key, state);
+  }
+  if (state.count < threshold) return;
+  let dominant = status2;
+  let max = 0;
+  for (const [code, n] of state.codes) {
+    if (n > max) {
+      max = n;
+      dominant = code;
+    }
+  }
+  await recordFailingResponseIncident(
+    ctx,
+    span,
+    affectedNode,
+    state.lastTs,
+    dominant,
+    state.count,
+    state.firstTs
+  );
+  ctx.burstState.delete(key);
+}
 async function handleSpan(ctx, span) {
   const ts = span.startTimeIso ?? nowIso(ctx);
   const nowMs = ctx.now ? ctx.now() : Date.now();
@@ -2660,6 +2760,14 @@ async function handleSpan(ctx, span) {
       await appendErrorEvent(ctx, ev);
     }
   }
+  if (span.statusCode !== 2) {
+    const status2 = httpResponseStatus(span);
+    if (status2 !== void 0 && status2 >= 500) {
+      await recordFailingResponseIncident(ctx, span, sourceId, ts, status2, 1);
+    } else if (status2 !== void 0 && status2 >= 400 && spanMintsObservedEdge(span.kind)) {
+      await advance4xxBurst(ctx, span, sourceId, ts, nowMs, status2);
+    }
+  }
   void affectedNode;
   if (ctx.onPolicyTrigger) await ctx.onPolicyTrigger(ctx.graph);
 }
@@ -4679,7 +4787,7 @@ async function addConfigNodes(graph, services, scanPath) {
 
 // src/extract/calls/index.ts
 init_cjs_shims();
-var import_types17 = require("@neat.is/types");
+var import_types18 = require("@neat.is/types");
 
 // src/extract/calls/http.ts
 init_cjs_shims();
@@ -5032,15 +5140,75 @@ function grpcEndpointsFromFile(file, serviceDir) {
   return out;
 }
 
+// src/extract/calls/supabase.ts
+init_cjs_shims();
+var import_node_path29 = __toESM(require("path"), 1);
+var import_types17 = require("@neat.is/types");
+var SUPABASE_JS_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@supabase\/supabase-js['"`]/;
+var SUPABASE_SSR_IMPORT_RE = /(?:from\s+['"`]|require\(\s*['"`])@supabase\/ssr['"`]/;
+var SUPABASE_CLIENT_RE = /\b(createClient|createServerClient|createBrowserClient)\s*\(\s*(?:['"`]([^'"`]*)['"`])?/g;
+function hostFromLiteral(literal) {
+  if (!literal) return null;
+  const m = /^https?:\/\/([^/:'"`\s]+)/.exec(literal.trim());
+  if (!m) return null;
+  const host = m[1];
+  if (!/\.supabase\.(co|in)$/i.test(host)) return null;
+  return host;
+}
+function readImports2(content) {
+  return {
+    hasSupabaseJs: SUPABASE_JS_IMPORT_RE.test(content),
+    hasSupabaseSsr: SUPABASE_SSR_IMPORT_RE.test(content)
+  };
+}
+function constructorMatchesImport(name, ctx) {
+  if (name === "createClient") return ctx.hasSupabaseJs;
+  return ctx.hasSupabaseSsr;
+}
+function supabaseEndpointsFromFile(file, serviceDir) {
+  const ctx = readImports2(file.content);
+  if (!ctx.hasSupabaseJs && !ctx.hasSupabaseSsr) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  SUPABASE_CLIENT_RE.lastIndex = 0;
+  let m;
+  while ((m = SUPABASE_CLIENT_RE.exec(file.content)) !== null) {
+    const ctor = m[1];
+    if (!constructorMatchesImport(ctor, ctx)) continue;
+    const host = hostFromLiteral(m[2]);
+    const name = host ?? "env";
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const line = lineOf(file.content, m[0]);
+    out.push({
+      infraId: (0, import_types17.infraId)("supabase", name),
+      name,
+      kind: "supabase",
+      edgeType: "CALLS",
+      // `createClient(...)` from @supabase/supabase-js (or createServerClient /
+      // createBrowserClient from @supabase/ssr) with the import in scope — a
+      // framework-aware recognizer matched the SDK shape. Verified-call-site
+      // tier (ADR-066), the same grade aws.ts / grpc.ts emit at.
+      confidenceKind: "verified-call-site",
+      evidence: {
+        file: import_node_path29.default.relative(serviceDir, file.path),
+        line,
+        snippet: snippet(file.content, line)
+      }
+    });
+  }
+  return out;
+}
+
 // src/extract/calls/index.ts
 function edgeTypeFromEndpoint(ep) {
   switch (ep.edgeType) {
     case "PUBLISHES_TO":
-      return import_types17.EdgeType.PUBLISHES_TO;
+      return import_types18.EdgeType.PUBLISHES_TO;
     case "CONSUMES_FROM":
-      return import_types17.EdgeType.CONSUMES_FROM;
+      return import_types18.EdgeType.CONSUMES_FROM;
     default:
-      return import_types17.EdgeType.CALLS;
+      return import_types18.EdgeType.CALLS;
   }
 }
 function isAwsKind(kind) {
@@ -5060,6 +5228,7 @@ async function addExternalEndpointEdges(graph, services) {
       endpoints.push(...redisEndpointsFromFile(maskedFile, service.dir));
       endpoints.push(...awsEndpointsFromFile(maskedFile, service.dir));
       endpoints.push(...grpcEndpointsFromFile(maskedFile, service.dir));
+      endpoints.push(...supabaseEndpointsFromFile(maskedFile, service.dir));
     }
     if (endpoints.length === 0) continue;
     const seenEdges = /* @__PURE__ */ new Set();
@@ -5067,7 +5236,7 @@ async function addExternalEndpointEdges(graph, services) {
       if (!graph.hasNode(ep.infraId)) {
         const node = {
           id: ep.infraId,
-          type: import_types17.NodeType.InfraNode,
+          type: import_types18.NodeType.InfraNode,
           name: ep.name,
           // #238 — `aws-*` covers AWS-SDK client kinds (aws-s3, aws-dynamodb,
           // aws-cognito-identity-provider, …); `s3-` / `dynamodb-` cover the
@@ -5079,7 +5248,7 @@ async function addExternalEndpointEdges(graph, services) {
         nodesAdded++;
       }
       const edgeType = edgeTypeFromEndpoint(ep);
-      const confidence = (0, import_types17.confidenceForExtracted)(ep.confidenceKind);
+      const confidence = (0, import_types18.confidenceForExtracted)(ep.confidenceKind);
       const relFile = toPosix2(ep.evidence.file);
       const { fileNodeId, nodesAdded: n, edgesAdded: e } = ensureFileNode(
         graph,
@@ -5089,7 +5258,7 @@ async function addExternalEndpointEdges(graph, services) {
       );
       nodesAdded += n;
       edgesAdded += e;
-      if (!(0, import_types17.passesExtractedFloor)(confidence)) {
+      if (!(0, import_types18.passesExtractedFloor)(confidence)) {
         noteExtractedDropped({
           source: fileNodeId,
           target: ep.infraId,
@@ -5109,7 +5278,7 @@ async function addExternalEndpointEdges(graph, services) {
           source: fileNodeId,
           target: ep.infraId,
           type: edgeType,
-          provenance: import_types17.Provenance.EXTRACTED,
+          provenance: import_types18.Provenance.EXTRACTED,
           confidence,
           evidence: ep.evidence
         };
@@ -5134,16 +5303,16 @@ init_cjs_shims();
 
 // src/extract/infra/docker-compose.ts
 init_cjs_shims();
-var import_node_path29 = __toESM(require("path"), 1);
-var import_types19 = require("@neat.is/types");
+var import_node_path30 = __toESM(require("path"), 1);
+var import_types20 = require("@neat.is/types");
 
 // src/extract/infra/shared.ts
 init_cjs_shims();
-var import_types18 = require("@neat.is/types");
+var import_types19 = require("@neat.is/types");
 function makeInfraNode(kind, name, provider = "self", extras) {
   return {
-    id: (0, import_types18.infraId)(kind, name),
-    type: import_types18.NodeType.InfraNode,
+    id: (0, import_types19.infraId)(kind, name),
+    type: import_types19.NodeType.InfraNode,
     name,
     provider,
     kind,
@@ -5172,7 +5341,7 @@ function dependsOnList(value) {
 }
 function serviceNameToServiceNode(name, services) {
   for (const s of services) {
-    if (s.node.name === name || import_node_path29.default.basename(s.dir) === name) return s.node.id;
+    if (s.node.name === name || import_node_path30.default.basename(s.dir) === name) return s.node.id;
   }
   return null;
 }
@@ -5181,7 +5350,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_path29.default.join(scanPath, name);
+    const abs = import_node_path30.default.join(scanPath, name);
     if (await exists2(abs)) {
       composePath = abs;
       break;
@@ -5194,13 +5363,13 @@ async function addComposeInfra(graph, scanPath, services) {
   } catch (err) {
     recordExtractionError(
       "infra docker-compose",
-      import_node_path29.default.relative(scanPath, composePath),
+      import_node_path30.default.relative(scanPath, composePath),
       err
     );
     return { nodesAdded, edgesAdded };
   }
   if (!compose?.services) return { nodesAdded, edgesAdded };
-  const evidenceFile = import_node_path29.default.relative(scanPath, composePath).split(import_node_path29.default.sep).join("/");
+  const evidenceFile = import_node_path30.default.relative(scanPath, composePath).split(import_node_path30.default.sep).join("/");
   const composeNameToNodeId = /* @__PURE__ */ new Map();
   for (const [composeName, svc] of Object.entries(compose.services)) {
     const matchedServiceId = serviceNameToServiceNode(composeName, services);
@@ -5222,15 +5391,15 @@ async function addComposeInfra(graph, scanPath, services) {
     for (const dep of dependsOnList(svc.depends_on)) {
       const targetId = composeNameToNodeId.get(dep);
       if (!targetId) continue;
-      const edgeId = (0, import_types5.extractedEdgeId)(sourceId, targetId, import_types19.EdgeType.DEPENDS_ON);
+      const edgeId = (0, import_types5.extractedEdgeId)(sourceId, targetId, import_types20.EdgeType.DEPENDS_ON);
       if (graph.hasEdge(edgeId)) continue;
       const edge = {
         id: edgeId,
         source: sourceId,
         target: targetId,
-        type: import_types19.EdgeType.DEPENDS_ON,
-        provenance: import_types19.Provenance.EXTRACTED,
-        confidence: (0, import_types19.confidenceForExtracted)("structural"),
+        type: import_types20.EdgeType.DEPENDS_ON,
+        provenance: import_types20.Provenance.EXTRACTED,
+        confidence: (0, import_types20.confidenceForExtracted)("structural"),
         evidence: { file: evidenceFile }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -5242,9 +5411,9 @@ async function addComposeInfra(graph, scanPath, services) {
 
 // src/extract/infra/dockerfile.ts
 init_cjs_shims();
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 var import_node_fs17 = require("fs");
-var import_types20 = require("@neat.is/types");
+var import_types21 = require("@neat.is/types");
 function runtimeImage(content) {
   const lines = content.split("\n");
   let last = null;
@@ -5263,7 +5432,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
   let nodesAdded = 0;
   let edgesAdded = 0;
   for (const service of services) {
-    const dockerfilePath = import_node_path30.default.join(service.dir, "Dockerfile");
+    const dockerfilePath = import_node_path31.default.join(service.dir, "Dockerfile");
     if (!await exists2(dockerfilePath)) continue;
     let content;
     try {
@@ -5271,7 +5440,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
     } catch (err) {
       recordExtractionError(
         "infra dockerfile",
-        import_node_path30.default.relative(scanPath, dockerfilePath),
+        import_node_path31.default.relative(scanPath, dockerfilePath),
         err
       );
       continue;
@@ -5283,7 +5452,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
       graph.addNode(node.id, node);
       nodesAdded++;
     }
-    const relDockerfile = toPosix2(import_node_path30.default.relative(service.dir, dockerfilePath));
+    const relDockerfile = toPosix2(import_node_path31.default.relative(service.dir, dockerfilePath));
     const { fileNodeId, nodesAdded: fn, edgesAdded: fe } = ensureFileNode(
       graph,
       service.pkg.name,
@@ -5292,17 +5461,17 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
     );
     nodesAdded += fn;
     edgesAdded += fe;
-    const edgeId = (0, import_types5.extractedEdgeId)(fileNodeId, node.id, import_types20.EdgeType.RUNS_ON);
+    const edgeId = (0, import_types5.extractedEdgeId)(fileNodeId, node.id, import_types21.EdgeType.RUNS_ON);
     if (!graph.hasEdge(edgeId)) {
       const edge = {
         id: edgeId,
         source: fileNodeId,
         target: node.id,
-        type: import_types20.EdgeType.RUNS_ON,
-        provenance: import_types20.Provenance.EXTRACTED,
-        confidence: (0, import_types20.confidenceForExtracted)("structural"),
+        type: import_types21.EdgeType.RUNS_ON,
+        provenance: import_types21.Provenance.EXTRACTED,
+        confidence: (0, import_types21.confidenceForExtracted)("structural"),
         evidence: {
-          file: toPosix2(import_node_path30.default.relative(scanPath, dockerfilePath))
+          file: toPosix2(import_node_path31.default.relative(scanPath, dockerfilePath))
         }
       };
       graph.addEdgeWithKey(edgeId, edge.source, edge.target, edge);
@@ -5315,7 +5484,7 @@ async function addDockerfileRuntimes(graph, services, scanPath) {
 // src/extract/infra/terraform.ts
 init_cjs_shims();
 var import_node_fs18 = require("fs");
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __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 [];
@@ -5324,11 +5493,11 @@ async function walkTfFiles(start, depth = 0, max = 5) {
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name) || entry.name === ".terraform") continue;
-      const child = import_node_path31.default.join(start, entry.name);
+      const child = import_node_path32.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkTfFiles(child, depth + 1, max));
     } else if (entry.isFile() && entry.name.endsWith(".tf")) {
-      out.push(import_node_path31.default.join(start, entry.name));
+      out.push(import_node_path32.default.join(start, entry.name));
     }
   }
   return out;
@@ -5356,7 +5525,7 @@ async function addTerraformResources(graph, scanPath) {
 // src/extract/infra/k8s.ts
 init_cjs_shims();
 var import_node_fs19 = require("fs");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 var import_yaml3 = require("yaml");
 var K8S_KIND_TO_INFRA_KIND = {
   Service: "k8s-service",
@@ -5374,11 +5543,11 @@ async function walkYamlFiles2(start, depth = 0, max = 5) {
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const child = import_node_path32.default.join(start, entry.name);
+      const child = import_node_path33.default.join(start, entry.name);
       if (await isPythonVenvDir(child)) continue;
       out.push(...await walkYamlFiles2(child, depth + 1, max));
-    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path32.default.extname(entry.name))) {
-      out.push(import_node_path32.default.join(start, entry.name));
+    } else if (entry.isFile() && CONFIG_FILE_EXTENSIONS.has(import_node_path33.default.extname(entry.name))) {
+      out.push(import_node_path33.default.join(start, entry.name));
     }
   }
   return out;
@@ -5422,17 +5591,17 @@ async function addInfra(graph, scanPath, services) {
 }
 
 // src/extract/index.ts
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_path35 = __toESM(require("path"), 1);
 
 // src/extract/retire.ts
 init_cjs_shims();
 var import_node_fs20 = require("fs");
-var import_node_path33 = __toESM(require("path"), 1);
-var import_types21 = require("@neat.is/types");
+var import_node_path34 = __toESM(require("path"), 1);
+var import_types22 = require("@neat.is/types");
 function dropOrphanedFileNodes(graph) {
   const orphans = [];
   graph.forEachNode((id, attrs) => {
-    if (attrs.type !== import_types21.NodeType.FileNode) return;
+    if (attrs.type !== import_types22.NodeType.FileNode) return;
     if (graph.inboundEdges(id).length === 0 && graph.outboundEdges(id).length === 0) {
       orphans.push(id);
     }
@@ -5445,14 +5614,14 @@ function retireExtractedEdgesByMissingFile(graph, scanPath, serviceDirs = []) {
   const bases = [scanPath, ...serviceDirs];
   graph.forEachEdge((id, attrs) => {
     const edge = attrs;
-    if (edge.provenance !== import_types21.Provenance.EXTRACTED) return;
+    if (edge.provenance !== import_types22.Provenance.EXTRACTED) return;
     const evidenceFile = edge.evidence?.file;
     if (!evidenceFile) return;
-    if (import_node_path33.default.isAbsolute(evidenceFile)) {
+    if (import_node_path34.default.isAbsolute(evidenceFile)) {
       if (!(0, import_node_fs20.existsSync)(evidenceFile)) toDrop.push(id);
       return;
     }
-    const found = bases.some((base) => (0, import_node_fs20.existsSync)(import_node_path33.default.join(base, evidenceFile)));
+    const found = bases.some((base) => (0, import_node_fs20.existsSync)(import_node_path34.default.join(base, evidenceFile)));
     if (!found) toDrop.push(id);
   });
   for (const id of toDrop) graph.dropEdge(id);
@@ -5492,7 +5661,7 @@ async function extractFromDirectory(graph, scanPath, opts = {}) {
   }
   const droppedEntries = drainDroppedExtracted();
   if (isRejectedLogEnabled() && opts.errorsPath && droppedEntries.length > 0) {
-    const rejectedPath = import_node_path34.default.join(import_node_path34.default.dirname(opts.errorsPath), "rejected.ndjson");
+    const rejectedPath = import_node_path35.default.join(import_node_path35.default.dirname(opts.errorsPath), "rejected.ndjson");
     try {
       await writeRejectedExtracted(droppedEntries, rejectedPath);
     } catch (err) {
@@ -5604,8 +5773,8 @@ function canonicalJson(value) {
 // src/persist.ts
 init_cjs_shims();
 var import_node_fs22 = require("fs");
-var import_node_path35 = __toESM(require("path"), 1);
-var import_types22 = require("@neat.is/types");
+var import_node_path36 = __toESM(require("path"), 1);
+var import_types23 = require("@neat.is/types");
 var SCHEMA_VERSION = 4;
 function migrateV1ToV2(payload) {
   const nodes = payload.graph.nodes;
@@ -5627,12 +5796,12 @@ function migrateV2ToV3(payload) {
     for (const edge of edges) {
       const attrs = edge.attributes;
       if (!attrs || attrs.provenance !== "FRONTIER") continue;
-      attrs.provenance = import_types22.Provenance.OBSERVED;
+      attrs.provenance = import_types23.Provenance.OBSERVED;
       const type = typeof attrs.type === "string" ? attrs.type : void 0;
       const source = typeof attrs.source === "string" ? attrs.source : void 0;
       const target = typeof attrs.target === "string" ? attrs.target : void 0;
       if (type && source && target) {
-        const newId = (0, import_types22.observedEdgeId)(source, target, type);
+        const newId = (0, import_types23.observedEdgeId)(source, target, type);
         attrs.id = newId;
         if (edge.key) edge.key = newId;
       }
@@ -5641,7 +5810,7 @@ function migrateV2ToV3(payload) {
   return { ...payload, schemaVersion: 3 };
 }
 async function ensureDir(filePath) {
-  await import_node_fs22.promises.mkdir(import_node_path35.default.dirname(filePath), { recursive: true });
+  await import_node_fs22.promises.mkdir(import_node_path36.default.dirname(filePath), { recursive: true });
 }
 async function saveGraphToDisk(graph, outPath) {
   await ensureDir(outPath);
@@ -5716,23 +5885,23 @@ function startPersistLoop(graph, outPath, intervalMs = 6e4) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_path36 = __toESM(require("path"), 1);
+var import_node_path37 = __toESM(require("path"), 1);
 function pathsForProject(project, baseDir) {
   if (project === DEFAULT_PROJECT) {
     return {
-      snapshotPath: import_node_path36.default.join(baseDir, "graph.json"),
-      errorsPath: import_node_path36.default.join(baseDir, "errors.ndjson"),
-      staleEventsPath: import_node_path36.default.join(baseDir, "stale-events.ndjson"),
-      embeddingsCachePath: import_node_path36.default.join(baseDir, "embeddings.json"),
-      policyViolationsPath: import_node_path36.default.join(baseDir, "policy-violations.ndjson")
+      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")
     };
   }
   return {
-    snapshotPath: import_node_path36.default.join(baseDir, `${project}.json`),
-    errorsPath: import_node_path36.default.join(baseDir, `errors.${project}.ndjson`),
-    staleEventsPath: import_node_path36.default.join(baseDir, `stale-events.${project}.ndjson`),
-    embeddingsCachePath: import_node_path36.default.join(baseDir, `embeddings.${project}.json`),
-    policyViolationsPath: import_node_path36.default.join(baseDir, `policy-violations.${project}.ndjson`)
+    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`)
   };
 }
 var Projects = class {
@@ -5774,15 +5943,15 @@ function parseExtraProjects(raw) {
 init_cjs_shims();
 var import_node_fs23 = require("fs");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path37 = __toESM(require("path"), 1);
-var import_types23 = require("@neat.is/types");
+var import_node_path38 = __toESM(require("path"), 1);
+var import_types24 = require("@neat.is/types");
 function neatHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return import_node_path37.default.resolve(override);
-  return import_node_path37.default.join(import_node_os3.default.homedir(), ".neat");
+  if (override && override.length > 0) return import_node_path38.default.resolve(override);
+  return import_node_path38.default.join(import_node_os3.default.homedir(), ".neat");
 }
 function registryPath() {
-  return import_node_path37.default.join(neatHome(), "projects.json");
+  return import_node_path38.default.join(neatHome(), "projects.json");
 }
 async function readRegistry() {
   const file = registryPath();
@@ -5796,7 +5965,7 @@ async function readRegistry() {
     throw err;
   }
   const parsed = JSON.parse(raw);
-  return import_types23.RegistryFileSchema.parse(parsed);
+  return import_types24.RegistryFileSchema.parse(parsed);
 }
 async function getProject(name) {
   const reg = await readRegistry();
@@ -5806,6 +5975,8 @@ async function listProjects() {
   const reg = await readRegistry();
   return reg.projects;
 }
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var DEFAULT_PRUNE_TTL_MS = 7 * DAY_MS2;
 
 // src/streaming.ts
 init_cjs_shims();
@@ -5819,6 +5990,7 @@ function handleSse(req, reply, opts) {
   reply.raw.setHeader("Connection", "keep-alive");
   reply.raw.setHeader("X-Accel-Buffering", "no");
   reply.raw.flushHeaders?.();
+  reply.raw.write(":open\n\n");
   let pending = 0;
   let dropped = false;
   const closeConnection = () => {
@@ -5998,11 +6170,11 @@ function registerRoutes(scope, ctx) {
       const candidates = req.query.type.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
       const parsed = [];
       for (const c of candidates) {
-        const r = import_types24.DivergenceTypeSchema.safeParse(c);
+        const r = import_types25.DivergenceTypeSchema.safeParse(c);
         if (!r.success) {
           return reply.code(400).send({
             error: `unknown divergence type "${c}"`,
-            allowed: import_types24.DivergenceTypeSchema.options
+            allowed: import_types25.DivergenceTypeSchema.options
           });
         }
         parsed.push(r.data);
@@ -6215,7 +6387,7 @@ function registerRoutes(scope, ctx) {
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
     if (req.query.severity) {
-      const sev = import_types24.PolicySeveritySchema.safeParse(req.query.severity);
+      const sev = import_types25.PolicySeveritySchema.safeParse(req.query.severity);
       if (!sev.success) {
         return reply.code(400).send({
           error: "invalid severity",
@@ -6232,7 +6404,7 @@ function registerRoutes(scope, ctx) {
   scope.post("/policies/check", async (req, reply) => {
     const proj = resolveProject(registry, req, reply, ctx.bootstrap);
     if (!proj) return;
-    const parsed = import_types24.PoliciesCheckBodySchema.safeParse(req.body ?? {});
+    const parsed = import_types25.PoliciesCheckBodySchema.safeParse(req.body ?? {});
     if (!parsed.success) {
       return reply.code(400).send({
         error: "invalid /policies/check body",
@@ -6475,7 +6647,7 @@ init_otel_grpc();
 // src/search.ts
 init_cjs_shims();
 var import_node_fs24 = require("fs");
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 var import_node_crypto3 = require("crypto");
 var DEFAULT_LIMIT = 10;
 var NOMIC_DIM = 768;
@@ -6614,7 +6786,7 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, cache) {
-  await import_node_fs24.promises.mkdir(import_node_path40.default.dirname(cachePath), { recursive: true });
+  await import_node_fs24.promises.mkdir(import_node_path41.default.dirname(cachePath), { recursive: true });
   await import_node_fs24.promises.writeFile(cachePath, JSON.stringify(cache));
 }
 var VectorIndex = class {
@@ -6795,14 +6967,14 @@ async function bootProject(registry, name, scanPath, baseDir) {
 async function main() {
   const baseDirEnv = process.env.NEAT_OUT_DIR;
   const legacyOutPath = process.env.NEAT_OUT_PATH;
-  const baseDir = baseDirEnv ? import_node_path41.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path41.default.resolve(import_node_path41.default.dirname(legacyOutPath)) : import_node_path41.default.resolve("./neat-out");
-  const defaultScanPath = import_node_path41.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
+  const baseDir = baseDirEnv ? import_node_path42.default.resolve(baseDirEnv) : legacyOutPath ? import_node_path42.default.resolve(import_node_path42.default.dirname(legacyOutPath)) : import_node_path42.default.resolve("./neat-out");
+  const defaultScanPath = import_node_path42.default.resolve(process.env.NEAT_SCAN_PATH ?? "./demo");
   const registry = new Projects();
   await bootProject(registry, DEFAULT_PROJECT, defaultScanPath, baseDir);
   for (const name of parseExtraProjects(process.env.NEAT_PROJECTS)) {
     const envKey = `NEAT_PROJECT_SCAN_PATH_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
     const projectScan = process.env[envKey];
-    await bootProject(registry, name, projectScan ? import_node_path41.default.resolve(projectScan) : void 0, baseDir);
+    await bootProject(registry, name, projectScan ? import_node_path42.default.resolve(projectScan) : void 0, baseDir);
   }
   const host = process.env.HOST ?? "0.0.0.0";
   const port = Number(process.env.PORT ?? 8080);