@launchsecure/launch-kit 0.0.14 → 0.0.15

package/dist/server/chart-serve.js

@@ -624,19 +624,26 @@ init_config();
 // src/server/graph/core/resolve-paths.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path2 = require("node:path");
+function detectDbDir(rootDir, config) {
+  if (config.paths?.dbDir) return (0, import_node_path2.join)(rootDir, config.paths.dbDir);
+  const prismaDir = (0, import_node_path2.join)(rootDir, "prisma");
+  if ((0, import_node_fs2.existsSync)(prismaDir)) return prismaDir;
+  return null;
+}
 function resolveProjectPaths(rootDir, config) {
+  const dbDir = detectDbDir(rootDir, config);
   if (config.paths?.appDir) {
     const appDir = (0, import_node_path2.join)(rootDir, config.paths.appDir);
     const srcDir = config.paths.srcDir ? (0, import_node_path2.join)(rootDir, config.paths.srcDir) : (0, import_node_path2.dirname)(appDir);
-    return { srcDir, appDir, apiDir: (0, import_node_path2.join)(appDir, "api") };
+    return { srcDir, appDir, apiDir: (0, import_node_path2.join)(appDir, "api"), dbDir };
   }
   const srcApp = (0, import_node_path2.join)(rootDir, "src", "app");
   if ((0, import_node_fs2.existsSync)(srcApp)) {
-    return { srcDir: (0, import_node_path2.join)(rootDir, "src"), appDir: srcApp, apiDir: (0, import_node_path2.join)(srcApp, "api") };
+    return { srcDir: (0, import_node_path2.join)(rootDir, "src"), appDir: srcApp, apiDir: (0, import_node_path2.join)(srcApp, "api"), dbDir };
   }
   const rootApp = (0, import_node_path2.join)(rootDir, "app");
   if ((0, import_node_fs2.existsSync)(rootApp)) {
-    return { srcDir: rootDir, appDir: rootApp, apiDir: (0, import_node_path2.join)(rootApp, "api") };
+    return { srcDir: rootDir, appDir: rootApp, apiDir: (0, import_node_path2.join)(rootApp, "api"), dbDir };
   }
   return null;
 }
@@ -2000,6 +2007,7 @@ function resolveUrlPath(urlPath, apiPathMap, apiRoutes) {
 var fetchResolverParser = {
   id: "fetch-resolver",
   layer: "crosslayer",
+  concern: "api-binding",
   detect(_rootDir) {
     return true;
   },
@@ -2113,6 +2121,7 @@ function toNodeId2(srcDir, absPath) {
 var apiAnnotationsParser = {
   id: "api-annotations",
   layer: "crosslayer",
+  concern: "api-binding",
   detect(rootDir) {
     return (0, import_node_fs7.existsSync)((0, import_node_path7.join)(rootDir, "src"));
   },
@@ -2199,6 +2208,7 @@ function toNodeId3(srcDir, absPath) {
 var urlLiteralScannerParser = {
   id: "url-literal-scanner",
   layer: "crosslayer",
+  concern: "api-binding",
   detect(rootDir) {
     const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
     return paths !== null;
@@ -2810,6 +2820,7 @@ function collectStaticRefsRegex(content, valueLookup, allValues) {
 var staticRefScannerParser = {
   id: "static-ref-scanner",
   layer: "crosslayer",
+  concern: "static-ref",
   detect(rootDir) {
     const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
     return paths !== null;
@@ -2994,6 +3005,9 @@ function loadCustomParsers(registry, config, rootDir, disabled) {
 `
         );
       }
+      if (parser.layer === "crosslayer" && entry.concern && !("concern" in parser && parser.concern)) {
+        parser.concern = entry.concern;
+      }
       registry.register(parser);
     } catch (err) {
       process.stderr.write(`[launch-chart] failed to load custom parser from ${entry.path}: ${err}
@@ -3091,44 +3105,21 @@ function dedupCrossRefs(refs) {
   }
   return result;
 }
-function applyCrossLayerResults(uiOutput, results, primaryId) {
-  const allCrossRefs = [...uiOutput.cross_refs];
-  const allFlagged = [...uiOutput.flagged_edges];
-  const allWarnings = [...uiOutput.warnings];
-  const primaryResult = results.find((r) => r.parserId === primaryId);
-  const secondaryResults = results.filter((r) => r.parserId !== primaryId);
-  if (primaryResult) {
-    allCrossRefs.push(...primaryResult.output.cross_refs);
-    allFlagged.push(...primaryResult.output.flagged_edges);
-    allWarnings.push(...primaryResult.output.warnings);
-  }
-  const primarySet = new Set(
-    (primaryResult?.output.cross_refs ?? []).map((r) => `${r.source}|${r.target}|${r.type}`)
-  );
-  for (const sec of secondaryResults) {
-    for (const ref of sec.output.cross_refs) {
-      const key = `${ref.source}|${ref.target}|${ref.type}`;
-      if (primarySet.has(key)) {
-        allCrossRefs.push(ref);
-      } else {
-        allFlagged.push({
-          source: ref.source,
-          target: ref.target,
-          type: "out_of_pattern",
-          label: `API call detected by ${sec.parserId} but not by primary (${primaryId})`,
-          confidence: "medium"
-        });
-        allCrossRefs.push(ref);
-      }
-    }
-    allFlagged.push(...sec.output.flagged_edges);
-    allWarnings.push(...sec.output.warnings);
-  }
+function applyCrossLayerResults(uiOutput, results) {
   return {
     ...uiOutput,
-    cross_refs: dedupCrossRefs(allCrossRefs),
-    flagged_edges: allFlagged,
-    warnings: allWarnings
+    cross_refs: dedupCrossRefs([
+      ...uiOutput.cross_refs,
+      ...results.flatMap((r) => r.output.cross_refs)
+    ]),
+    flagged_edges: [
+      ...uiOutput.flagged_edges,
+      ...results.flatMap((r) => r.output.flagged_edges)
+    ],
+    warnings: [
+      ...uiOutput.warnings,
+      ...results.flatMap((r) => r.output.warnings)
+    ]
   };
 }
 
@@ -3167,10 +3158,9 @@ function generateLayer(rootDir, layer) {
       if (existing) layerOutputs.set(otherLayer, existing);
     }
     const crossParsers = registry.getCrossLayerParsers();
-    const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
     const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
     if (crossResults.length > 0) {
-      merged = applyCrossLayerResults(merged, crossResults, primaryId);
+      merged = applyCrossLayerResults(merged, crossResults);
     }
   }
   return {
@@ -3217,11 +3207,10 @@ function generateAll(rootDir) {
     });
   }
   const crossParsers = registry.getCrossLayerParsers();
-  const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
   const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
   if (crossResults.length > 0 && layerOutputs.has("ui")) {
     const uiOutput = layerOutputs.get("ui");
-    const merged = applyCrossLayerResults(uiOutput, crossResults, primaryId);
+    const merged = applyCrossLayerResults(uiOutput, crossResults);
     layerOutputs.set("ui", merged);
     const uiResult = results.find((r) => r.layer === "ui");
     if (uiResult) {
@@ -4386,17 +4375,23 @@ async function startChartServer(opts = {}) {
       if (req.method === "GET" && url2.pathname === "/api/parser-config") {
         const config2 = loadConfig(reqRoot);
         const registry = createRegistry(config2, reqRoot);
+        const toLabel = (id) => id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
         const detection = [];
         for (const parser of registry.getAll()) {
           if ("layers" in parser && Array.isArray(parser.layers)) {
             const mp = parser;
-            detection.push({ id: mp.id, layers: mp.layers, detected: mp.detect(reqRoot) });
+            detection.push({ id: mp.id, layers: mp.layers, label: toLabel(mp.id), detected: mp.detect(reqRoot) });
           } else if ("layer" in parser && parser.layer !== "crosslayer") {
             const sp = parser;
-            detection.push({ id: sp.id, layers: [sp.layer], detected: sp.detect(reqRoot) });
+            detection.push({ id: sp.id, layers: [sp.layer], label: toLabel(sp.id), detected: sp.detect(reqRoot) });
           }
         }
-        const crosslayerParsers = registry.getCrossLayerParsers().map((p) => ({ id: p.id }));
+        const crosslayerParsers = {};
+        for (const p of registry.getCrossLayerParsers()) {
+          const concern = p.concern ?? "api-binding";
+          if (!crosslayerParsers[concern]) crosslayerParsers[concern] = [];
+          crosslayerParsers[concern].push({ id: p.id, label: toLabel(p.id) });
+        }
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ config: config2, detection, crosslayerParsers }));
         return;
@@ -4509,16 +4504,21 @@ async function startChartServer(opts = {}) {
       if (req.method === "GET" && url2.pathname === "/api/detected-paths") {
         const config2 = loadConfig(reqRoot);
         const paths = resolveProjectPaths(reqRoot, config2);
-        const isOverride = !!config2.paths?.appDir;
+        const overrides = {
+          appDir: !!config2.paths?.appDir,
+          dbDir: !!config2.paths?.dbDir
+        };
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
           projectRoot: reqRoot,
           detected: paths ? {
             srcDir: import_node_path19.default.relative(reqRoot, paths.srcDir) || ".",
             appDir: import_node_path19.default.relative(reqRoot, paths.appDir),
-            apiDir: import_node_path19.default.relative(reqRoot, paths.apiDir)
+            apiDir: import_node_path19.default.relative(reqRoot, paths.apiDir),
+            dbDir: paths.dbDir ? import_node_path19.default.relative(reqRoot, paths.dbDir) : null
           } : null,
-          isOverride
+          overrides,
+          isOverride: overrides.appDir
         }));
         return;
       }

package/dist/server/cli.js

@@ -6906,19 +6906,26 @@ init_config();
 // src/server/graph/core/resolve-paths.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path2 = require("node:path");
+function detectDbDir(rootDir, config) {
+  if (config.paths?.dbDir) return (0, import_node_path2.join)(rootDir, config.paths.dbDir);
+  const prismaDir = (0, import_node_path2.join)(rootDir, "prisma");
+  if ((0, import_node_fs2.existsSync)(prismaDir)) return prismaDir;
+  return null;
+}
 function resolveProjectPaths(rootDir, config) {
+  const dbDir = detectDbDir(rootDir, config);
   if (config.paths?.appDir) {
     const appDir = (0, import_node_path2.join)(rootDir, config.paths.appDir);
     const srcDir = config.paths.srcDir ? (0, import_node_path2.join)(rootDir, config.paths.srcDir) : (0, import_node_path2.dirname)(appDir);
-    return { srcDir, appDir, apiDir: (0, import_node_path2.join)(appDir, "api") };
+    return { srcDir, appDir, apiDir: (0, import_node_path2.join)(appDir, "api"), dbDir };
   }
   const srcApp = (0, import_node_path2.join)(rootDir, "src", "app");
   if ((0, import_node_fs2.existsSync)(srcApp)) {
-    return { srcDir: (0, import_node_path2.join)(rootDir, "src"), appDir: srcApp, apiDir: (0, import_node_path2.join)(srcApp, "api") };
+    return { srcDir: (0, import_node_path2.join)(rootDir, "src"), appDir: srcApp, apiDir: (0, import_node_path2.join)(srcApp, "api"), dbDir };
   }
   const rootApp = (0, import_node_path2.join)(rootDir, "app");
   if ((0, import_node_fs2.existsSync)(rootApp)) {
-    return { srcDir: rootDir, appDir: rootApp, apiDir: (0, import_node_path2.join)(rootApp, "api") };
+    return { srcDir: rootDir, appDir: rootApp, apiDir: (0, import_node_path2.join)(rootApp, "api"), dbDir };
   }
   return null;
 }
@@ -8282,6 +8289,7 @@ function resolveUrlPath(urlPath, apiPathMap, apiRoutes) {
 var fetchResolverParser = {
   id: "fetch-resolver",
   layer: "crosslayer",
+  concern: "api-binding",
   detect(_rootDir) {
     return true;
   },
@@ -8395,6 +8403,7 @@ function toNodeId2(srcDir, absPath) {
 var apiAnnotationsParser = {
   id: "api-annotations",
   layer: "crosslayer",
+  concern: "api-binding",
   detect(rootDir) {
     return (0, import_node_fs7.existsSync)((0, import_node_path7.join)(rootDir, "src"));
   },
@@ -8481,6 +8490,7 @@ function toNodeId3(srcDir, absPath) {
 var urlLiteralScannerParser = {
   id: "url-literal-scanner",
   layer: "crosslayer",
+  concern: "api-binding",
   detect(rootDir) {
     const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
     return paths !== null;
@@ -9092,6 +9102,7 @@ function collectStaticRefsRegex(content, valueLookup, allValues) {
 var staticRefScannerParser = {
   id: "static-ref-scanner",
   layer: "crosslayer",
+  concern: "static-ref",
   detect(rootDir) {
     const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
     return paths !== null;
@@ -9276,6 +9287,9 @@ function loadCustomParsers(registry, config, rootDir, disabled) {
 `
         );
       }
+      if (parser.layer === "crosslayer" && entry.concern && !("concern" in parser && parser.concern)) {
+        parser.concern = entry.concern;
+      }
       registry.register(parser);
     } catch (err2) {
       process.stderr.write(`[launch-chart] failed to load custom parser from ${entry.path}: ${err2}
@@ -9373,44 +9387,21 @@ function dedupCrossRefs(refs) {
   }
   return result;
 }
-function applyCrossLayerResults(uiOutput, results, primaryId) {
-  const allCrossRefs = [...uiOutput.cross_refs];
-  const allFlagged = [...uiOutput.flagged_edges];
-  const allWarnings = [...uiOutput.warnings];
-  const primaryResult = results.find((r) => r.parserId === primaryId);
-  const secondaryResults = results.filter((r) => r.parserId !== primaryId);
-  if (primaryResult) {
-    allCrossRefs.push(...primaryResult.output.cross_refs);
-    allFlagged.push(...primaryResult.output.flagged_edges);
-    allWarnings.push(...primaryResult.output.warnings);
-  }
-  const primarySet = new Set(
-    (primaryResult?.output.cross_refs ?? []).map((r) => `${r.source}|${r.target}|${r.type}`)
-  );
-  for (const sec of secondaryResults) {
-    for (const ref of sec.output.cross_refs) {
-      const key = `${ref.source}|${ref.target}|${ref.type}`;
-      if (primarySet.has(key)) {
-        allCrossRefs.push(ref);
-      } else {
-        allFlagged.push({
-          source: ref.source,
-          target: ref.target,
-          type: "out_of_pattern",
-          label: `API call detected by ${sec.parserId} but not by primary (${primaryId})`,
-          confidence: "medium"
-        });
-        allCrossRefs.push(ref);
-      }
-    }
-    allFlagged.push(...sec.output.flagged_edges);
-    allWarnings.push(...sec.output.warnings);
-  }
+function applyCrossLayerResults(uiOutput, results) {
   return {
     ...uiOutput,
-    cross_refs: dedupCrossRefs(allCrossRefs),
-    flagged_edges: allFlagged,
-    warnings: allWarnings
+    cross_refs: dedupCrossRefs([
+      ...uiOutput.cross_refs,
+      ...results.flatMap((r) => r.output.cross_refs)
+    ]),
+    flagged_edges: [
+      ...uiOutput.flagged_edges,
+      ...results.flatMap((r) => r.output.flagged_edges)
+    ],
+    warnings: [
+      ...uiOutput.warnings,
+      ...results.flatMap((r) => r.output.warnings)
+    ]
   };
 }
 
@@ -9449,10 +9440,9 @@ function generateLayer(rootDir, layer) {
       if (existing) layerOutputs.set(otherLayer, existing);
     }
     const crossParsers = registry.getCrossLayerParsers();
-    const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
     const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
     if (crossResults.length > 0) {
-      merged = applyCrossLayerResults(merged, crossResults, primaryId);
+      merged = applyCrossLayerResults(merged, crossResults);
     }
   }
   return {
@@ -9499,11 +9489,10 @@ function generateAll(rootDir) {
     });
   }
   const crossParsers = registry.getCrossLayerParsers();
-  const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
   const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
   if (crossResults.length > 0 && layerOutputs.has("ui")) {
     const uiOutput = layerOutputs.get("ui");
-    const merged = applyCrossLayerResults(uiOutput, crossResults, primaryId);
+    const merged = applyCrossLayerResults(uiOutput, crossResults);
     layerOutputs.set("ui", merged);
     const uiResult = results.find((r) => r.layer === "ui");
     if (uiResult) {
@@ -10901,6 +10890,41 @@ Use this when the user asks "is the chart running", "show me the project graph U
       },
       required: ["layer"]
     }
+  },
+  {
+    name: "blast_points",
+    description: `Calculate the blast radius for a node \u2014 what depends on it across all project layers. Returns reverse dependencies aggregated with hop distance and summary stats.
+
+USE THIS when assessing the impact of changing a file, table, or endpoint. Replaces multiple read_graph calls with a single query that:
+- Traverses REVERSE edges (who imports/depends on this node)
+- Searches across ALL layers if layer is omitted
+- Returns affected nodes with hop distance, type, layer, and module
+- Provides a summary with counts by layer, by hop, and risk assessment
+
+Example: blast_points(node_id: "server/auth/middleware.ts", hops: 2) \u2192 returns all files that import middleware.ts, and all files that import THOSE files.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        node_id: {
+          type: "string",
+          description: "The node to analyze (file path, table name, etc.)"
+        },
+        layer: {
+          type: "string",
+          description: "Layer the node lives in (e.g. 'ui', 'api', 'db'). Omit to auto-detect by searching all layers."
+        },
+        hops: {
+          type: "number",
+          description: "Max hops to traverse outward. Default 2."
+        },
+        direction: {
+          type: "string",
+          enum: ["reverse", "both"],
+          description: "'reverse' (default) = only what depends on this node. 'both' = full neighborhood."
+        }
+      },
+      required: ["node_id"]
+    }
   }
 ];
 function matchesSearch(node, query) {
@@ -11058,6 +11082,125 @@ function neighborhood(graph, centerId, hops, layer, minimal) {
   const edges = graph.edges.filter((e) => visited.has(e.source) && visited.has(e.target));
   return { nodes, edges, budgetExceeded, stoppedAtHop };
 }
+function reverseNeighborhood(graph, centerId, hops, direction) {
+  const center = graph.nodes.find((n) => n.id === centerId);
+  if (!center) return { nodes: /* @__PURE__ */ new Map(), edges: [] };
+  const visited = /* @__PURE__ */ new Map();
+  visited.set(centerId, { node: center, hop: 0 });
+  let frontier = /* @__PURE__ */ new Set([centerId]);
+  for (let h = 0; h < hops; h++) {
+    const next = /* @__PURE__ */ new Set();
+    for (const edge of graph.edges) {
+      if (direction === "reverse") {
+        if (frontier.has(edge.target) && !visited.has(edge.source)) next.add(edge.source);
+      } else {
+        if (frontier.has(edge.source) && !visited.has(edge.target)) next.add(edge.target);
+        if (frontier.has(edge.target) && !visited.has(edge.source)) next.add(edge.source);
+      }
+    }
+    for (const id of next) {
+      const node = graph.nodes.find((n) => n.id === id);
+      if (node) visited.set(id, { node, hop: h + 1 });
+    }
+    frontier = next;
+    if (frontier.size === 0) break;
+  }
+  const nodeIds = new Set(visited.keys());
+  const edges = graph.edges.filter((e) => nodeIds.has(e.source) && nodeIds.has(e.target));
+  return { nodes: visited, edges };
+}
+function handleBlastPoints(args) {
+  const rootDir = process.cwd();
+  const nodeId = args.node_id;
+  const requestedLayer = args.layer;
+  const hops = args.hops ?? 2;
+  const direction = args.direction ?? "reverse";
+  let targetLayer = requestedLayer;
+  if (!targetLayer) {
+    const graphs = readAllGraphs(rootDir);
+    for (const [layer, graph2] of Object.entries(graphs)) {
+      if (graph2 && graph2.nodes.some((n) => n.id === nodeId)) {
+        targetLayer = layer;
+        break;
+      }
+    }
+    if (!targetLayer) {
+      return err(`Node "${nodeId}" not found in any layer. Available layers: ${getAvailableLayers(rootDir).join(", ")}`);
+    }
+  }
+  const graph = readGraph(rootDir, targetLayer);
+  if (!graph) {
+    return err(`No graph for layer "${targetLayer}". Run generate_graph first.`);
+  }
+  const center = graph.nodes.find((n) => n.id === nodeId);
+  if (!center) {
+    return err(`Node "${nodeId}" not found in ${targetLayer} layer.`);
+  }
+  const result = reverseNeighborhood(graph, nodeId, hops, direction);
+  const affected = [];
+  for (const [id, { node, hop }] of result.nodes) {
+    if (id === nodeId) continue;
+    const tags = node.tags;
+    affected.push({
+      id: node.id,
+      name: node.name,
+      type: node.type,
+      layer: targetLayer,
+      hop,
+      module: tags?.module
+    });
+  }
+  const otherLayers = getAvailableLayers(rootDir).filter((l) => l !== targetLayer && l !== "static");
+  for (const otherLayer of otherLayers) {
+    const otherGraph = readGraph(rootDir, otherLayer);
+    if (!otherGraph) continue;
+    for (const edge of otherGraph.edges) {
+      if (edge.target === nodeId || edge.source === nodeId) {
+        const dependentId = edge.target === nodeId ? edge.source : edge.target;
+        if (affected.some((a) => a.id === dependentId)) continue;
+        const depNode = otherGraph.nodes.find((n) => n.id === dependentId);
+        if (depNode) {
+          const tags = depNode.tags;
+          affected.push({
+            id: depNode.id,
+            name: depNode.name,
+            type: depNode.type,
+            layer: otherLayer,
+            hop: 1,
+            module: tags?.module
+          });
+        }
+      }
+    }
+  }
+  const byLayer = {};
+  const byHop = {};
+  const modulesSet = /* @__PURE__ */ new Set();
+  for (const a of affected) {
+    byLayer[a.layer] = (byLayer[a.layer] ?? 0) + 1;
+    byHop[String(a.hop)] = (byHop[String(a.hop)] ?? 0) + 1;
+    if (a.module) modulesSet.add(a.module);
+  }
+  const crossesLayers = Object.keys(byLayer).length > 1;
+  const centerTags = center.tags;
+  return okJson({
+    center: {
+      id: center.id,
+      name: center.name,
+      type: center.type,
+      layer: targetLayer,
+      module: centerTags?.module
+    },
+    affected,
+    summary: {
+      total: affected.length,
+      by_layer: byLayer,
+      by_hop: byHop,
+      modules_touched: Array.from(modulesSet).sort(),
+      crosses_layers: crossesLayers
+    }
+  });
+}
 function layerSummary(graph) {
   const typeCounts = {};
   const moduleCounts = {};
@@ -11619,16 +11762,13 @@ function handleDetectProjectStack() {
       for (const l of p.layers) availableLayers.add(l);
     }
   }
-  let stats = { calls_api: 0, references_api: 0, out_of_pattern: 0, annotations: 0 };
+  const stats = { calls_api: 0, references_api: 0, annotations: 0 };
   const uiGraph = readGraph(rootDir, "ui");
   if (uiGraph) {
     for (const ref of uiGraph.cross_refs ?? []) {
       if (ref.type === "calls_api") stats.calls_api++;
       if (ref.type === "references_api") stats.references_api++;
     }
-    for (const f of uiGraph.flagged_edges ?? []) {
-      if (f.type === "out_of_pattern") stats.out_of_pattern++;
-    }
   }
   const srcDir = (0, import_node_path20.join)(rootDir, "src");
   if ((0, import_node_fs18.existsSync)(srcDir)) {
@@ -11652,12 +11792,6 @@ function handleDetectProjectStack() {
     };
     scanDir(srcDir);
   }
-  let recommendedPrimary = "fetch-resolver";
-  if (stats.annotations > 0 && stats.annotations >= stats.calls_api) {
-    recommendedPrimary = "api-annotations";
-  } else if (stats.calls_api === 0 && stats.references_api > 0) {
-    recommendedPrimary = "url-literal-scanner";
-  }
   const supportedLanguages = /* @__PURE__ */ new Map();
   supportedLanguages.set("typescript", parserResults.filter((p) => p.detected && p.layers.some((l) => l === "ui" || l === "api")).map((p) => p.id));
   supportedLanguages.set("prisma", parserResults.filter((p) => p.detected && p.layers.includes("db")).map((p) => p.id));
@@ -11668,13 +11802,22 @@ function handleDetectProjectStack() {
     languages,
     parsers: parserResults,
     available_layers: [...availableLayers],
-    crosslayer_parsers: [
-      { id: "fetch-resolver", description: "Detects direct fetch()/api.get() calls with inline URLs" },
-      { id: "api-annotations", description: "Scans for @api METHOD /path annotations in JSDoc/comments" },
-      { id: "url-literal-scanner", description: "Finds /api/... string literals as fallback detection" }
-    ],
+    crosslayer_parsers: (() => {
+      const descriptions = {
+        "fetch-resolver": "Detects direct fetch()/api.get() calls with inline URLs",
+        "api-annotations": "Scans for @api METHOD /path annotations in JSDoc/comments",
+        "url-literal-scanner": "Finds /api/... string literals as fallback detection",
+        "static-ref-scanner": "Finds references to static values (enums, permissions, roles)"
+      };
+      const grouped = {};
+      for (const p of registry.getCrossLayerParsers()) {
+        const concern = p.concern ?? "api-binding";
+        if (!grouped[concern]) grouped[concern] = [];
+        grouped[concern].push({ id: p.id, description: descriptions[p.id] ?? p.id });
+      }
+      return grouped;
+    })(),
     stats,
-    recommended_primary: recommendedPrimary,
     ...unsupportedHint ? { unsupported_hint: unsupportedHint } : {},
     current_config: Object.keys(config).length > 0 ? config : null,
     config_path: ".launchchart.json"
@@ -11755,6 +11898,10 @@ async function handleMessage(msg) {
       respond(id ?? null, handleAuditLayer(args));
       return;
     }
+    if (toolName === "blast_points") {
+      respond(id ?? null, handleBlastPoints(args));
+      return;
+    }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
     return;
   }