@launchsecure/launch-kit 0.0.17 → 0.0.19

package/dist/server/graph-mcp-entry.js

@@ -155,36 +155,248 @@ var init_config = __esm({
   }
 });
 
+// src/server/graph/core/walk.ts
+function walk(dir, exts) {
+  const results = [];
+  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path3.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk(full, exts));
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function walkWithIgnore(dir, exts, opts = {}) {
+  const results = [];
+  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  const skip = opts.extraIgnore ? /* @__PURE__ */ new Set([...DEFAULT_IGNORE_DIRS, ...opts.extraIgnore]) : DEFAULT_IGNORE_DIRS;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (skip.has(entry.name)) continue;
+      results.push(...walkWithIgnore((0, import_node_path3.join)(dir, entry.name), exts, opts));
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+      results.push((0, import_node_path3.join)(dir, entry.name));
+    }
+  }
+  return results;
+}
+var import_node_fs3, import_node_path3, DEFAULT_IGNORE_DIRS;
+var init_walk = __esm({
+  "src/server/graph/core/walk.ts"() {
+    "use strict";
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
+    DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".next",
+      ".launchsecure",
+      ".claude",
+      "dist",
+      "build",
+      "out",
+      ".turbo",
+      ".vercel",
+      "coverage"
+    ]);
+  }
+});
+
 // src/server/graph/core/resolve-paths.ts
-function detectDbDir(rootDir, config) {
-  if (config.paths?.dbDir) return (0, import_node_path3.join)(rootDir, config.paths.dbDir);
-  const prismaDir = (0, import_node_path3.join)(rootDir, "prisma");
-  if ((0, import_node_fs3.existsSync)(prismaDir)) return prismaDir;
-  return null;
+function hasSqlFiles(dir) {
+  if (!(0, import_node_fs4.existsSync)(dir)) return false;
+  try {
+    return (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isFile() && e.name.endsWith(".sql")
+    );
+  } catch {
+    return false;
+  }
 }
-function resolveProjectPaths(rootDir, config) {
-  const dbDir = detectDbDir(rootDir, config);
-  if (config.paths?.appDir) {
-    const appDir = (0, import_node_path3.join)(rootDir, config.paths.appDir);
-    const srcDir = config.paths.srcDir ? (0, import_node_path3.join)(rootDir, config.paths.srcDir) : (0, import_node_path3.dirname)(appDir);
-    return { srcDir, appDir, apiDir: (0, import_node_path3.join)(appDir, "api"), dbDir };
+function hasNestedMigrationSql(dir) {
+  if (!(0, import_node_fs4.existsSync)(dir)) return false;
+  try {
+    return (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isDirectory() && (0, import_node_fs4.existsSync)((0, import_node_path4.join)(dir, e.name, "migration.sql"))
+    );
+  } catch {
+    return false;
+  }
+}
+function resolveDbFromDir(dir) {
+  if (!(0, import_node_fs4.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
+  const schemaPath = (0, import_node_path4.join)(dir, "schema.prisma");
+  if ((0, import_node_fs4.existsSync)(schemaPath)) {
+    const migrationsDir2 = (0, import_node_path4.join)(dir, "migrations");
+    return {
+      kind: "prisma",
+      schemaPath,
+      migrationsDir: (0, import_node_fs4.existsSync)(migrationsDir2) ? migrationsDir2 : null
+    };
   }
-  const srcApp = (0, import_node_path3.join)(rootDir, "src", "app");
-  if ((0, import_node_fs3.existsSync)(srcApp)) {
-    return { srcDir: (0, import_node_path3.join)(rootDir, "src"), appDir: srcApp, apiDir: (0, import_node_path3.join)(srcApp, "api"), dbDir };
+  const migrationsDir = (0, import_node_path4.join)(dir, "migrations");
+  if (hasSqlFiles(migrationsDir) || hasNestedMigrationSql(migrationsDir)) {
+    return { kind: "sql-migrations", migrationsDir, schemaPath: null };
   }
-  const rootApp = (0, import_node_path3.join)(rootDir, "app");
-  if ((0, import_node_fs3.existsSync)(rootApp)) {
-    return { srcDir: rootDir, appDir: rootApp, apiDir: (0, import_node_path3.join)(rootApp, "api"), dbDir };
+  if (hasSqlFiles(dir) || hasNestedMigrationSql(dir)) {
+    return { kind: "sql-migrations", migrationsDir: dir, schemaPath: null };
   }
+  return { kind: "none", schemaPath: null, migrationsDir: null };
+}
+function detectDbConfig(rootDir, config) {
+  if (config.paths?.dbDir) {
+    return resolveDbFromDir((0, import_node_path4.join)(rootDir, config.paths.dbDir));
+  }
+  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path4.join)("db", "migrations"), "migrations"];
+  for (const c of candidates) {
+    const dir = (0, import_node_path4.join)(rootDir, c);
+    const resolved = resolveDbFromDir(dir);
+    if (resolved.kind !== "none") return resolved;
+  }
+  return { kind: "none", schemaPath: null, migrationsDir: null };
+}
+function detectDbDir(rootDir, config, dbConfig) {
+  if (config.paths?.dbDir) return (0, import_node_path4.join)(rootDir, config.paths.dbDir);
+  if (dbConfig.kind === "prisma") return (0, import_node_path4.dirname)(dbConfig.schemaPath);
+  if (dbConfig.kind === "sql-migrations") return dbConfig.migrationsDir;
   return null;
 }
-var import_node_fs3, import_node_path3;
+function dirHasTSFiles(dir) {
+  if (!(0, import_node_fs4.existsSync)(dir)) return false;
+  try {
+    const stack = [dir];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      const entries = (0, import_node_fs4.readdirSync)(cur, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx"))) return true;
+        if (e.isDirectory() && !e.name.startsWith(".") && !DEFAULT_IGNORE_DIRS.has(e.name)) {
+          stack.push((0, import_node_path4.join)(cur, e.name));
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function collectCodeBearingChildren(dir, extraSkip) {
+  if (!(0, import_node_fs4.existsSync)(dir)) return [];
+  const out = [];
+  try {
+    for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      if (NON_SOURCE_DIRS.has(entry.name)) continue;
+      if (extraSkip?.has(entry.name)) continue;
+      const full = (0, import_node_path4.join)(dir, entry.name);
+      if (dirHasTSFiles(full)) out.push(full);
+    }
+  } catch {
+  }
+  return out;
+}
+function detectSrcRoots(rootDir, srcDir, appDir, config) {
+  if (config.paths?.srcRoots && config.paths.srcRoots.length > 0) {
+    const roots2 = /* @__PURE__ */ new Set();
+    roots2.add(appDir);
+    for (const r of config.paths.srcRoots) {
+      const abs = (0, import_node_path4.isAbsolute)(r) ? r : (0, import_node_path4.resolve)(rootDir, r);
+      roots2.add(abs);
+    }
+    return [...roots2];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  roots.add(appDir);
+  for (const c of collectCodeBearingChildren(srcDir)) roots.add(c);
+  if (srcDir !== rootDir) {
+    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path4.basename)(srcDir)]);
+    for (const c of collectCodeBearingChildren(rootDir, skipSrcWrapper)) roots.add(c);
+  }
+  return [...roots];
+}
+function detectConventionFiles(rootDir, srcDir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirs = srcDir === rootDir ? [rootDir] : [srcDir, rootDir];
+  for (const dir of dirs) {
+    for (const name of CONVENTION_NAMES) {
+      const full = (0, import_node_path4.join)(dir, name);
+      if (!seen.has(full) && (0, import_node_fs4.existsSync)(full)) {
+        try {
+          if ((0, import_node_fs4.statSync)(full).isFile()) {
+            seen.add(full);
+            out.push(full);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return out;
+}
+function resolveProjectPaths(rootDir, config) {
+  let srcDir;
+  let appDir;
+  if (config.paths?.appDir) {
+    appDir = (0, import_node_path4.join)(rootDir, config.paths.appDir);
+    srcDir = config.paths.srcDir ? (0, import_node_path4.join)(rootDir, config.paths.srcDir) : (0, import_node_path4.dirname)(appDir);
+  } else {
+    const srcApp = (0, import_node_path4.join)(rootDir, "src", "app");
+    const rootApp = (0, import_node_path4.join)(rootDir, "app");
+    if ((0, import_node_fs4.existsSync)(srcApp)) {
+      srcDir = (0, import_node_path4.join)(rootDir, "src");
+      appDir = srcApp;
+    } else if ((0, import_node_fs4.existsSync)(rootApp)) {
+      srcDir = rootDir;
+      appDir = rootApp;
+    } else {
+      return null;
+    }
+  }
+  const apiDir = (0, import_node_path4.join)(appDir, "api");
+  const dbConfig = detectDbConfig(rootDir, config);
+  const dbDir = detectDbDir(rootDir, config, dbConfig);
+  const srcRoots = detectSrcRoots(rootDir, srcDir, appDir, config);
+  const conventionFiles = detectConventionFiles(rootDir, srcDir);
+  return { srcDir, appDir, apiDir, dbDir, srcRoots, conventionFiles, dbConfig };
+}
+var import_node_fs4, import_node_path4, NON_SOURCE_DIRS, CONVENTION_NAMES;
 var init_resolve_paths = __esm({
   "src/server/graph/core/resolve-paths.ts"() {
     "use strict";
-    import_node_fs3 = require("node:fs");
-    import_node_path3 = require("node:path");
+    import_node_fs4 = require("node:fs");
+    import_node_path4 = require("node:path");
+    init_walk();
+    NON_SOURCE_DIRS = /* @__PURE__ */ new Set([
+      ...DEFAULT_IGNORE_DIRS,
+      // DB conventions (handled by db parsers)
+      "prisma",
+      "supabase",
+      "drizzle",
+      "migrations",
+      // Web assets
+      "public",
+      "static",
+      "assets",
+      // Docs
+      "docs",
+      "documentation",
+      // Test dirs (project tests aren't part of the structural graph)
+      "tests",
+      "__tests__",
+      "e2e",
+      "playwright",
+      "cypress",
+      // Monorepo workspace roots — separate graph projects per .launchchart.json
+      "packages",
+      "apps",
+      "services",
+      "libs"
+    ]);
+    CONVENTION_NAMES = ["middleware.ts", "middleware.tsx", "instrumentation.ts", "instrumentation.tsx"];
   }
 });
 
@@ -224,15 +436,15 @@ function getQuery(name) {
   ensureInit();
   const cached = queryCache.get(name);
   if (cached) return cached;
-  const scmPath = (0, import_node_path4.join)(queriesDir, `${name}.scm`);
-  const scm = (0, import_node_fs4.readFileSync)(scmPath, "utf-8");
+  const scmPath = (0, import_node_path5.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs5.readFileSync)(scmPath, "utf-8");
   const query = tsxLanguage.query(scm);
   queryCache.set(name, query);
   return query;
 }
 function parseSource(absPath) {
   ensureInit();
-  const content = (0, import_node_fs4.readFileSync)(absPath, "utf-8");
+  const content = (0, import_node_fs5.readFileSync)(absPath, "utf-8");
   return parserInstance.parse(content);
 }
 function parseCodeTS(code) {
@@ -697,17 +909,17 @@ function extractDeep(absPath) {
   }
   return { elements, stateVars, conditions, variables, responses, params };
 }
-var import_node_fs4, import_node_path4, tsxLanguage, parserInstance, initPromise, initialized, queriesDir, queryCache, PRISMA_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods;
+var import_node_fs5, import_node_path5, tsxLanguage, parserInstance, initPromise, initialized, queriesDir, queryCache, PRISMA_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods;
 var init_ts_extractor = __esm({
   "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
-    import_node_fs4 = require("node:fs");
-    import_node_path4 = require("node:path");
+    import_node_fs5 = require("node:fs");
+    import_node_path5 = require("node:path");
     initialized = false;
     queriesDir = (() => {
-      const srcPath = (0, import_node_path4.join)((0, import_node_path4.dirname)(__filename), "..", "queries");
+      const srcPath = (0, import_node_path5.join)((0, import_node_path5.dirname)(__filename), "..", "queries");
       if (require("fs").existsSync(srcPath)) return srcPath;
-      return (0, import_node_path4.join)((0, import_node_path4.dirname)(__filename), "graph", "queries");
+      return (0, import_node_path5.join)((0, import_node_path5.dirname)(__filename), "graph", "queries");
     })();
     queryCache = /* @__PURE__ */ new Map();
     PRISMA_MUTATION_METHODS_BUILTIN = [
@@ -728,48 +940,26 @@ var init_ts_extractor = __esm({
 });
 
 // src/server/graph/parsers/ts/typescript-project.ts
-function walk(dir, exts) {
-  const results = [];
-  if (!(0, import_node_fs5.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path5.join)(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path5.extname)(entry.name))) {
-      results.push(full);
-    }
+function toNodeId(srcDir, rootDir, absPath) {
+  const relFromSrc = (0, import_node_path6.relative)(srcDir, absPath).replace(/\\/g, "/");
+  if (relFromSrc.startsWith("..")) {
+    return (0, import_node_path6.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
-  return results;
-}
-function walkWithIgnore(dir, exts, ignoreDirs) {
-  const results = [];
-  if (!(0, import_node_fs5.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      if (ignoreDirs.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path5.join)(dir, entry.name), exts, ignoreDirs));
-    } else if (exts.includes((0, import_node_path5.extname)(entry.name))) {
-      results.push((0, import_node_path5.join)(dir, entry.name));
-    }
-  }
-  return results;
-}
-function toNodeId(srcDir, absPath) {
-  return (0, import_node_path5.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return relFromSrc;
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
   const rel = specifier.slice(2);
-  const base = (0, import_node_path5.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path5.join)(base, "index.ts"), (0, import_node_path5.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs5.existsSync)(c) && (0, import_node_fs5.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path6.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path6.join)(base, "index.ts"), (0, import_node_path6.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs6.existsSync)(c) && (0, import_node_fs6.statSync)(c).isFile()) return c;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path5.join)((0, import_node_path5.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path5.join)(base, "index.ts"), (0, import_node_path5.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs5.existsSync)(c) && (0, import_node_fs5.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path6.join)((0, import_node_path6.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path6.join)(base, "index.ts"), (0, import_node_path6.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs6.existsSync)(c) && (0, import_node_fs6.statSync)(c).isFile()) return c;
   }
   return null;
 }
@@ -790,7 +980,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path5.basename)(resolved);
+      const targetBn = (0, import_node_path6.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -817,12 +1007,12 @@ function buildAllBarrelMaps(srcDir, parsedByPath) {
   const barrels = /* @__PURE__ */ new Map();
   const memo = /* @__PURE__ */ new Map();
   for (const [absPath, parsed] of parsedByPath) {
-    const bn = (0, import_node_path5.basename)(absPath);
+    const bn = (0, import_node_path6.basename)(absPath);
     if (bn !== "index.ts" && bn !== "index.tsx") continue;
     if (parsed.reExports.length === 0) continue;
     const map = resolveBarrelMap(absPath, parsedByPath, memo, /* @__PURE__ */ new Set());
     if (map.size > 0) {
-      const barrelId = (0, import_node_path5.relative)(srcDir, (0, import_node_path5.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path6.relative)(srcDir, (0, import_node_path6.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -843,14 +1033,15 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path5.basename)(absPath, (0, import_node_path5.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  return (0, import_node_path6.basename)(absPath, (0, import_node_path6.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
-function filePathToApiRoute(apiDir, absPath) {
-  let route = "/" + (0, import_node_path5.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+function filePathToAppRoute(appDir, absPath) {
+  let route = ("/" + (0, import_node_path6.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
+  route = route.replace(/\/\([^)]+\)/g, "");
+  route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
   route = route.replace(/\[([^\]]+)\]/g, ":$1");
   route = route.replace(/\/+/g, "/");
-  if (route === "/") return "/api";
-  return "/api" + route;
+  return route === "" ? "/" : route;
 }
 function camelToPascal(s) {
   if (!s) return s;
@@ -935,7 +1126,7 @@ function matchRouteToPage(route, routeToNodeId) {
   if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
   return null;
 }
-function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps, routeToNodeId) {
+function extractEdges(srcDir, rootDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps, routeToNodeId) {
   const edges = [];
   const flagged = [];
   const seen = /* @__PURE__ */ new Set();
@@ -963,7 +1154,7 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
         for (const name of names) {
           const targetAbs = barrelMap.get(name);
           if (targetAbs) {
-            const targetId = toNodeId(srcDir, targetAbs);
+            const targetId = toNodeId(srcDir, rootDir, targetAbs);
             if (nodeIdSet.has(targetId)) {
               if (!byTarget.has(targetId)) byTarget.set(targetId, []);
               byTarget.get(targetId).push(name);
@@ -977,7 +1168,7 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
       } else {
         const resolved = resolveImport(srcDir, specifier);
         if (resolved) {
-          const targetId = toNodeId(srcDir, resolved);
+          const targetId = toNodeId(srcDir, rootDir, resolved);
           if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
             addEdge(targetId, edgeTypeFor(isTypeOnly, names));
           }
@@ -986,7 +1177,7 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
     } else if (specifier.startsWith(".")) {
       const resolved = resolveRelativeImport(absPath, specifier);
       if (resolved) {
-        const targetId = toNodeId(srcDir, resolved);
+        const targetId = toNodeId(srcDir, rootDir, resolved);
         if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
           addEdge(targetId, edgeTypeFor(isTypeOnly, names));
         }
@@ -1030,24 +1221,30 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
   }
   return { edges, flagged };
 }
-function hasNextConfig(rootDir) {
-  return (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "next.config.ts")) || (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "next.config.js")) || (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "next.config.mjs"));
-}
 function detect(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  return paths !== null && hasNextConfig(rootDir);
+  return paths !== null;
 }
 function generate(rootDir) {
   const config = loadConfig(rootDir);
   const paths = resolveProjectPaths(rootDir, config);
   const srcDir = paths.srcDir;
-  const apiDir = paths.apiDir;
-  const appFiles = walk(paths.appDir, [".tsx", ".ts"]);
-  const clientFiles = walk((0, import_node_path5.join)(srcDir, "client"), [".tsx", ".ts"]);
-  const serverFiles = walk((0, import_node_path5.join)(srcDir, "server"), [".ts", ".tsx"]);
-  const libFiles = walk((0, import_node_path5.join)(srcDir, "lib"), [".ts", ".tsx"]);
-  const configFiles = walk((0, import_node_path5.join)(srcDir, "config"), [".ts", ".tsx"]);
-  const allDiscovered = [...appFiles, ...clientFiles, ...serverFiles, ...libFiles, ...configFiles];
+  const allDiscovered = [];
+  const discoveredSet = /* @__PURE__ */ new Set();
+  for (const root of paths.srcRoots) {
+    for (const f of walk(root, [".tsx", ".ts"])) {
+      if (!discoveredSet.has(f)) {
+        discoveredSet.add(f);
+        allDiscovered.push(f);
+      }
+    }
+  }
+  for (const conv of paths.conventionFiles) {
+    if (!discoveredSet.has(conv)) {
+      discoveredSet.add(conv);
+      allDiscovered.push(conv);
+    }
+  }
   const parsedByPath = /* @__PURE__ */ new Map();
   for (const absPath of allDiscovered) {
     parsedByPath.set(absPath, parseFileTS(absPath));
@@ -1057,9 +1254,9 @@ function generate(rootDir) {
   const apiNodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const routeToNodeId = /* @__PURE__ */ new Map();
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path5.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path6.basename)(f).startsWith("index."));
   for (const absPath of fileSet) {
-    const id = toNodeId(srcDir, absPath);
+    const id = toNodeId(srcDir, rootDir, absPath);
     const type = classifyType(absPath, id);
     if (type === "test" || type === "story") continue;
     const parsed = parsedByPath.get(absPath);
@@ -1074,7 +1271,7 @@ function generate(rootDir) {
       const dbCalls = extractDbCallsTS(absPath);
       const authWrappers = extractAuthWrappersTS(absPath);
       const deep = extractDeep(absPath);
-      const routePath = (0, import_node_fs5.existsSync)(apiDir) ? filePathToApiRoute(apiDir, absPath) : `/api/${id.replace(/\/route\.tsx?$/, "")}`;
+      const routePath = filePathToAppRoute(paths.appDir, absPath);
       const mutations = dbCalls.filter((c) => c.isMutation);
       const mutates = mutations.length > 0;
       const authStrategy = [...authWrappers];
@@ -1118,11 +1315,12 @@ function generate(rootDir) {
   const uiEdges = [];
   const uiFlagged = [];
   for (const absPath of fileSet) {
-    const id = toNodeId(srcDir, absPath);
+    const id = toNodeId(srcDir, rootDir, absPath);
     if (!nodeIdSet.has(id)) continue;
     const parsed = parsedByPath.get(absPath);
     const { edges, flagged } = extractEdges(
       srcDir,
+      rootDir,
       absPath,
       id,
       parsed,
@@ -1135,7 +1333,7 @@ function generate(rootDir) {
   }
   const fetchCallEntries = [];
   for (const absPath of fileSet) {
-    const sourceId = toNodeId(srcDir, absPath);
+    const sourceId = toNodeId(srcDir, rootDir, absPath);
     if (!nodeIdSet.has(sourceId)) continue;
     const parsed = parsedByPath.get(absPath);
     if (parsed.fetchCalls.length === 0) continue;
@@ -1151,20 +1349,7 @@ function generate(rootDir) {
     });
   }
   const externalScanned = new Set(allDiscovered.map((f) => f.replace(/\\/g, "/")));
-  const IGNORE_DIRS2 = /* @__PURE__ */ new Set([
-    "node_modules",
-    ".next",
-    "dist",
-    ".launchsecure",
-    ".git",
-    "src",
-    "coverage",
-    ".turbo",
-    "build",
-    "out",
-    ".vercel"
-  ]);
-  const externalCandidates = walkWithIgnore(rootDir, [".ts", ".tsx"], IGNORE_DIRS2);
+  const externalCandidates = walkWithIgnore(rootDir, [".ts", ".tsx"], { extraIgnore: /* @__PURE__ */ new Set(["src"]) });
   for (const absPath of externalCandidates) {
     const normalized = absPath.replace(/\\/g, "/");
     if (externalScanned.has(normalized)) continue;
@@ -1174,7 +1359,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path5.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path6.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -1187,7 +1372,7 @@ function generate(rootDir) {
           for (const name of names) {
             const targetAbs = barrelMap.get(name);
             if (!targetAbs) continue;
-            const targetId2 = toNodeId(srcDir, targetAbs);
+            const targetId2 = toNodeId(srcDir, rootDir, targetAbs);
             if (!nodeIdSet.has(targetId2)) continue;
             const key2 = `${externalId}\u2192${targetId2}`;
             if (seen.has(key2)) continue;
@@ -1201,7 +1386,7 @@ function generate(rootDir) {
         resolved = resolveRelativeImport(absPath, specifier);
       }
       if (!resolved) continue;
-      const targetId = toNodeId(srcDir, resolved);
+      const targetId = toNodeId(srcDir, rootDir, resolved);
       if (!nodeIdSet.has(targetId)) continue;
       if (targetId.endsWith("/index.ts") || targetId.endsWith("/index.tsx")) continue;
       const key = `${externalId}\u2192${targetId}`;
@@ -1370,14 +1555,15 @@ function generate(rootDir) {
   }
   return result;
 }
-var import_node_fs5, import_node_path5, HTTP_METHODS, CLASSIFICATION_TO_LAYER, typescriptProjectParser;
+var import_node_fs6, import_node_path6, HTTP_METHODS, CLASSIFICATION_TO_LAYER, typescriptProjectParser;
 var init_typescript_project = __esm({
   "src/server/graph/parsers/ts/typescript-project.ts"() {
     "use strict";
-    import_node_fs5 = require("node:fs");
-    import_node_path5 = require("node:path");
+    import_node_fs6 = require("node:fs");
+    import_node_path6 = require("node:path");
     init_config();
     init_resolve_paths();
+    init_walk();
     init_ts_extractor();
     HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
     CLASSIFICATION_TO_LAYER = {
@@ -1493,11 +1679,25 @@ function parseEnums(content) {
   return nodes;
 }
 function detect2(rootDir) {
-  return (0, import_node_fs6.existsSync)((0, import_node_path6.join)(rootDir, "prisma", "schema.prisma"));
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs7.existsSync)(paths.dbConfig.schemaPath);
 }
 function generate2(rootDir) {
-  const schemaPath = (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
-  const content = (0, import_node_fs6.readFileSync)(schemaPath, "utf-8");
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (paths.dbConfig.kind !== "prisma") {
+    return {
+      metadata: { generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), layer: "db", source: "none" },
+      nodes: [],
+      edges: [],
+      cross_refs: [],
+      contradictions: [],
+      warnings: [],
+      flagged_edges: [],
+      patterns: { total_tables: 0, total_enums: 0, total_relations: 0 }
+    };
+  }
+  const schemaPath = paths.dbConfig.schemaPath;
+  const content = (0, import_node_fs7.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -1517,7 +1717,7 @@ function generate2(rootDir) {
     metadata: {
       generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
       scope: "prisma-schema",
-      source: "prisma/schema.prisma",
+      source: schemaPath,
       provider: "postgresql",
       layer: "db",
       total_models: modelNodes.length,
@@ -1546,12 +1746,13 @@ function generate2(rootDir) {
     }
   };
 }
-var import_node_fs6, import_node_path6, prismaSchemaParser;
+var import_node_fs7, prismaSchemaParser;
 var init_prisma_schema = __esm({
   "src/server/graph/parsers/db/prisma-schema.ts"() {
     "use strict";
-    import_node_fs6 = require("node:fs");
-    import_node_path6 = require("node:path");
+    import_node_fs7 = require("node:fs");
+    init_config();
+    init_resolve_paths();
     prismaSchemaParser = {
       id: "prisma-schema",
       layer: "db",
@@ -1684,20 +1885,30 @@ function parseUniqueIndex(sql, state) {
     state.uniqueIndexes.get(m[1]).add(m[2]);
   }
 }
-function parseMigrations(rootDir) {
-  const migrationsDir = (0, import_node_path7.join)(rootDir, "prisma", "migrations");
+function discoverMigrationFiles(migrationsDir) {
+  if (!(0, import_node_fs8.existsSync)(migrationsDir)) return [];
+  const out = [];
+  const entries = (0, import_node_fs8.readdirSync)(migrationsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const sqlPath = (0, import_node_path7.join)(migrationsDir, entry.name, "migration.sql");
+      if ((0, import_node_fs8.existsSync)(sqlPath)) out.push(sqlPath);
+    } else if (entry.isFile() && entry.name.endsWith(".sql")) {
+      out.push((0, import_node_path7.join)(migrationsDir, entry.name));
+    }
+  }
+  return out;
+}
+function parseMigrations(migrationsDir) {
   const state = {
     tables: /* @__PURE__ */ new Map(),
     enums: /* @__PURE__ */ new Map(),
     fks: [],
     uniqueIndexes: /* @__PURE__ */ new Map()
   };
-  if (!(0, import_node_fs7.existsSync)(migrationsDir)) return state;
-  const dirs = (0, import_node_fs7.readdirSync)(migrationsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
-  for (const dir of dirs) {
-    const sqlPath = (0, import_node_path7.join)(migrationsDir, dir, "migration.sql");
-    if (!(0, import_node_fs7.existsSync)(sqlPath)) continue;
-    const sql = (0, import_node_fs7.readFileSync)(sqlPath, "utf-8");
+  if (!migrationsDir) return state;
+  for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
+    const sql = (0, import_node_fs8.readFileSync)(sqlPath, "utf-8");
     parseCreateEnum(sql, state);
     parseCreateTable(sql, state);
     parseAlterTable(sql, state);
@@ -1707,10 +1918,9 @@ function parseMigrations(rootDir) {
   }
   return state;
 }
-function loadPrismaState(rootDir) {
-  const schemaPath = (0, import_node_path7.join)(rootDir, "prisma", "schema.prisma");
-  if (!(0, import_node_fs7.existsSync)(schemaPath)) return null;
-  const content = (0, import_node_fs7.readFileSync)(schemaPath, "utf-8");
+function loadPrismaState(schemaPath) {
+  if (!schemaPath || !(0, import_node_fs8.existsSync)(schemaPath)) return null;
+  const content = (0, import_node_fs8.readFileSync)(schemaPath, "utf-8");
   const tables = /* @__PURE__ */ new Map();
   const enums = /* @__PURE__ */ new Map();
   const relations = [];
@@ -1874,14 +2084,28 @@ function verify(sqlState, prisma) {
   }
   return { contradictions, flaggedEdges };
 }
+function migrationsDirFor(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (!paths) return null;
+  if (paths.dbConfig.kind === "prisma" || paths.dbConfig.kind === "sql-migrations") {
+    return paths.dbConfig.migrationsDir;
+  }
+  return null;
+}
+function schemaPathFor(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (!paths) return null;
+  return paths.dbConfig.kind === "prisma" ? paths.dbConfig.schemaPath : null;
+}
 function detect3(rootDir) {
-  const migrationsDir = (0, import_node_path7.join)(rootDir, "prisma", "migrations");
-  if (!(0, import_node_fs7.existsSync)(migrationsDir)) return false;
-  return (0, import_node_fs7.readdirSync)(migrationsDir, { withFileTypes: true }).some((d) => d.isDirectory() && (0, import_node_fs7.existsSync)((0, import_node_path7.join)(migrationsDir, d.name, "migration.sql")));
+  const dir = migrationsDirFor(rootDir);
+  if (!dir) return false;
+  return discoverMigrationFiles(dir).length > 0;
 }
 function generate3(rootDir) {
-  const sqlState = parseMigrations(rootDir);
-  const prisma = loadPrismaState(rootDir);
+  const migrationsDir = migrationsDirFor(rootDir);
+  const sqlState = parseMigrations(migrationsDir);
+  const prisma = loadPrismaState(schemaPathFor(rootDir));
   const prismaTableIds = prisma ? new Set(prisma.tables.keys()) : /* @__PURE__ */ new Set();
   const prismaEnumIds = prisma ? new Set(prisma.enums.keys()) : /* @__PURE__ */ new Set();
   const nodes = [];
@@ -1927,7 +2151,7 @@ function generate3(rootDir) {
     metadata: {
       generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
       scope: "sql-migrations",
-      source: "prisma/migrations/",
+      source: migrationsDir ?? "none",
       layer: "db",
       sql_tables: sqlState.tables.size,
       sql_enums: sqlState.enums.size,
@@ -1944,12 +2168,14 @@ function generate3(rootDir) {
     flagged_edges: flaggedEdges
   };
 }
-var import_node_fs7, import_node_path7, PG_TO_PRISMA, sqlMigrationsParser;
+var import_node_fs8, import_node_path7, PG_TO_PRISMA, sqlMigrationsParser;
 var init_sql_migrations = __esm({
   "src/server/graph/parsers/db/sql-migrations.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
+    import_node_fs8 = require("node:fs");
     import_node_path7 = require("node:path");
+    init_config();
+    init_resolve_paths();
     PG_TO_PRISMA = {
       "TEXT": "String",
       "VARCHAR": "String",
@@ -2212,9 +2438,9 @@ var init_fetch_resolver = __esm({
 
 // src/server/graph/parsers/crosslayer/api-annotations.ts
 function walk2(dir, exts) {
-  if (!(0, import_node_fs8.existsSync)(dir)) return [];
+  if (!(0, import_node_fs9.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
     const full = (0, import_node_path8.join)(dir, entry.name);
     if (entry.isDirectory()) {
@@ -2228,11 +2454,11 @@ function walk2(dir, exts) {
 function toNodeId2(srcDir, absPath) {
   return (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
-var import_node_fs8, import_node_path8, API_ANNOTATION_RE, apiAnnotationsParser;
+var import_node_fs9, import_node_path8, API_ANNOTATION_RE, apiAnnotationsParser;
 var init_api_annotations = __esm({
   "src/server/graph/parsers/crosslayer/api-annotations.ts"() {
     "use strict";
-    import_node_fs8 = require("node:fs");
+    import_node_fs9 = require("node:fs");
     import_node_path8 = require("node:path");
     init_api_route_matching();
     API_ANNOTATION_RE = /@api\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S+)/g;
@@ -2241,7 +2467,7 @@ var init_api_annotations = __esm({
       layer: "crosslayer",
       concern: "api-binding",
       detect(rootDir) {
-        return (0, import_node_fs8.existsSync)((0, import_node_path8.join)(rootDir, "src"));
+        return (0, import_node_fs9.existsSync)((0, import_node_path8.join)(rootDir, "src"));
       },
       generate(rootDir, layerOutputs) {
         const apiOutput = layerOutputs.get("api");
@@ -2258,7 +2484,7 @@ var init_api_annotations = __esm({
         const flaggedEdges = [];
         const seen = /* @__PURE__ */ new Set();
         for (const absPath of files) {
-          const content = (0, import_node_fs8.readFileSync)(absPath, "utf-8");
+          const content = (0, import_node_fs9.readFileSync)(absPath, "utf-8");
           const sourceId = toNodeId2(srcDir, absPath);
           if (!uiNodeIds.has(sourceId)) continue;
           let match;
@@ -2305,9 +2531,9 @@ var init_api_annotations = __esm({
 
 // src/server/graph/parsers/crosslayer/url-literal-scanner.ts
 function walk3(dir, exts) {
-  if (!(0, import_node_fs9.existsSync)(dir)) return [];
+  if (!(0, import_node_fs10.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
     const full = (0, import_node_path9.join)(dir, entry.name);
     if (entry.isDirectory()) {
@@ -2321,11 +2547,11 @@ function walk3(dir, exts) {
 function toNodeId3(srcDir, absPath) {
   return (0, import_node_path9.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
-var import_node_fs9, import_node_path9, URL_LITERAL_RE, urlLiteralScannerParser;
+var import_node_fs10, import_node_path9, URL_LITERAL_RE, urlLiteralScannerParser;
 var init_url_literal_scanner = __esm({
   "src/server/graph/parsers/crosslayer/url-literal-scanner.ts"() {
     "use strict";
-    import_node_fs9 = require("node:fs");
+    import_node_fs10 = require("node:fs");
     import_node_path9 = require("node:path");
     init_api_route_matching();
     init_config();
@@ -2360,7 +2586,7 @@ var init_url_literal_scanner = __esm({
         for (const absPath of files) {
           const sourceId = toNodeId3(srcDir, absPath);
           if (!uiNodeIds.has(sourceId)) continue;
-          const content = (0, import_node_fs9.readFileSync)(absPath, "utf-8");
+          const content = (0, import_node_fs10.readFileSync)(absPath, "utf-8");
           let match;
           URL_LITERAL_RE.lastIndex = 0;
           while ((match = URL_LITERAL_RE.exec(content)) !== null) {
@@ -2427,14 +2653,14 @@ function extractEnumValues(rootDir) {
   ];
   let content = "";
   for (const p of schemaPaths) {
-    if ((0, import_node_fs10.existsSync)(p)) {
+    if ((0, import_node_fs11.existsSync)(p)) {
       try {
-        const stat = (0, import_node_fs10.statSync)(p);
+        const stat = (0, import_node_fs11.statSync)(p);
         if (stat.isFile()) {
-          content = (0, import_node_fs10.readFileSync)(p, "utf-8");
+          content = (0, import_node_fs11.readFileSync)(p, "utf-8");
         } else if (stat.isDirectory()) {
-          const files = (0, import_node_fs10.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
-          content = files.map((f) => (0, import_node_fs10.readFileSync)((0, import_node_path10.join)(p, f), "utf-8")).join("\n");
+          const files = (0, import_node_fs11.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
+          content = files.map((f) => (0, import_node_fs11.readFileSync)((0, import_node_path10.join)(p, f), "utf-8")).join("\n");
         }
       } catch {
         continue;
@@ -2508,7 +2734,7 @@ function extractStringArrayFromNode(node) {
   return values;
 }
 function findArrayDecl(root, varName) {
-  function walk5(node) {
+  function walk4(node) {
     if (node.type === "variable_declarator") {
       const nameNode = node.childForFieldName("name");
       const valueNode = node.childForFieldName("value");
@@ -2521,12 +2747,12 @@ function findArrayDecl(root, varName) {
       }
     }
     for (const child of node.namedChildren) {
-      const found = walk5(child);
+      const found = walk4(child);
       if (found) return found;
     }
     return null;
   }
-  return walk5(root);
+  return walk4(root);
 }
 function extractObjectPropsRegex(objStr) {
   const props = {};
@@ -2593,10 +2819,10 @@ function extractSeedData(rootDir) {
     (0, import_node_path10.join)(rootDir, "prisma", "seed.ts"),
     (0, import_node_path10.join)(rootDir, "prisma", "seed.js"),
     (0, import_node_path10.join)(rootDir, "src", "server", "lib", "system-tags.ts")
-  ].filter(import_node_fs10.existsSync);
+  ].filter(import_node_fs11.existsSync);
   const useTreeSitter = tryLoadTreeSitter();
   for (const filePath of seedFiles) {
-    const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
     const relPath = (0, import_node_path10.relative)(rootDir, filePath);
     const seeded = detectSeededArrays(content, relPath);
     let astRoot = null;
@@ -2691,9 +2917,9 @@ function extractSeedData(rootDir) {
   return { nodes, edges };
 }
 function walkDir(dir, exts) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return [];
+  if (!(0, import_node_fs11.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
     const full = (0, import_node_path10.join)(dir, entry.name);
     if (entry.isDirectory()) results.push(...walkDir(full, exts));
@@ -2704,9 +2930,9 @@ function walkDir(dir, exts) {
 function extractConstants(rootDir) {
   const nodes = [];
   const srcDir = (0, import_node_path10.join)(rootDir, "src");
-  if (!(0, import_node_fs10.existsSync)(srcDir)) return { nodes };
+  if (!(0, import_node_fs11.existsSync)(srcDir)) return { nodes };
   for (const filePath of walkDir(srcDir, [".ts", ".tsx"])) {
-    const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
     const relPath = (0, import_node_path10.relative)(rootDir, filePath);
     const constArrayRe = /export\s+const\s+([A-Z][A-Z_0-9]+)\s*(?::[^=]+)?\s*=\s*\[/g;
     let cm;
@@ -2740,7 +2966,7 @@ function extractConstants(rootDir) {
   return { nodes };
 }
 function detect4(rootDir) {
-  return (0, import_node_fs10.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs10.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "seed.ts"));
+  return (0, import_node_fs11.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs11.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "seed.ts"));
 }
 function generate4(rootDir) {
   const enumResult = extractEnumValues(rootDir);
@@ -2807,11 +3033,11 @@ function generate4(rootDir) {
     }
   };
 }
-var import_node_fs10, import_node_path10, parseCode, SHARED_MODELS, DB_MODELS, staticValuesParser;
+var import_node_fs11, import_node_path10, parseCode, SHARED_MODELS, DB_MODELS, staticValuesParser;
 var init_static_values = __esm({
   "src/server/graph/parsers/static/static-values.ts"() {
     "use strict";
-    import_node_fs10 = require("node:fs");
+    import_node_fs11 = require("node:fs");
     import_node_path10 = require("node:path");
     parseCode = null;
     SHARED_MODELS = /* @__PURE__ */ new Set(["permission", "role", "tag"]);
@@ -2826,23 +3052,6 @@ var init_static_values = __esm({
 });
 
 // src/server/graph/parsers/crosslayer/static-ref-scanner.ts
-function walk4(dir, exts) {
-  if (!(0, import_node_fs11.existsSync)(dir)) return [];
-  const results = [];
-  function recurse(d) {
-    for (const entry of (0, import_node_fs11.readdirSync)(d, { withFileTypes: true })) {
-      const full = (0, import_node_path11.join)(d, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
-        recurse(full);
-      } else if (exts.some((ext) => entry.name.endsWith(ext))) {
-        results.push(full);
-      }
-    }
-  }
-  recurse(dir);
-  return results;
-}
 function isInCommentOrType(node) {
   let current = node.parent;
   while (current) {
@@ -2927,14 +3136,15 @@ function collectStaticRefsRegex(content, valueLookup, allValues) {
   }
   return refs;
 }
-var import_node_fs11, import_node_path11, MIN_VALUE_LENGTH, SKIP_VALUES, staticRefScannerParser;
+var import_node_fs12, import_node_path11, MIN_VALUE_LENGTH, SKIP_VALUES, staticRefScannerParser;
 var init_static_ref_scanner = __esm({
   "src/server/graph/parsers/crosslayer/static-ref-scanner.ts"() {
     "use strict";
-    import_node_fs11 = require("node:fs");
+    import_node_fs12 = require("node:fs");
     import_node_path11 = require("node:path");
     init_config();
     init_resolve_paths();
+    init_walk();
     MIN_VALUE_LENGTH = 4;
     SKIP_VALUES = /* @__PURE__ */ new Set([
       "true",
@@ -2993,11 +3203,11 @@ var init_static_ref_scanner = __esm({
         if (!paths) return { cross_refs: [], flagged_edges: [], warnings: [] };
         const srcDir = paths.srcDir;
         const files = [
-          ...walk4((0, import_node_path11.join)(srcDir, "client"), [".ts", ".tsx"]),
-          ...walk4(paths.appDir, [".ts", ".tsx"]),
-          ...walk4((0, import_node_path11.join)(srcDir, "server"), [".ts", ".tsx"]),
-          ...walk4((0, import_node_path11.join)(srcDir, "lib"), [".ts", ".tsx"]),
-          ...walk4((0, import_node_path11.join)(srcDir, "config"), [".ts", ".tsx"])
+          ...walkWithIgnore((0, import_node_path11.join)(srcDir, "client"), [".ts", ".tsx"]),
+          ...walkWithIgnore(paths.appDir, [".ts", ".tsx"]),
+          ...walkWithIgnore((0, import_node_path11.join)(srcDir, "server"), [".ts", ".tsx"]),
+          ...walkWithIgnore((0, import_node_path11.join)(srcDir, "lib"), [".ts", ".tsx"]),
+          ...walkWithIgnore((0, import_node_path11.join)(srcDir, "config"), [".ts", ".tsx"])
         ];
         const uiOutput = layerOutputs.get("ui");
         const apiOutput = layerOutputs.get("api");
@@ -3018,7 +3228,7 @@ var init_static_ref_scanner = __esm({
           const sourceId = (0, import_node_path11.relative)(srcDir, absPath).replace(/\\/g, "/");
           const sourceLayer = uiNodeIds.has(sourceId) ? "ui" : apiNodeIds.has(sourceId) ? "api" : null;
           if (!sourceLayer) continue;
-          const content = (0, import_node_fs11.readFileSync)(absPath, "utf-8");
+          const content = (0, import_node_fs12.readFileSync)(absPath, "utf-8");
           filesScanned++;
           let fileRefs;
           if (parseCode2) {
@@ -3287,9 +3497,9 @@ var init_merge = __esm({
 // src/server/graph/core/graph-builder.ts
 function readGraphFromDisk(rootDir, layer) {
   const filePath = (0, import_node_path13.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
-  if (!(0, import_node_fs12.existsSync)(filePath)) return null;
+  if (!(0, import_node_fs13.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs13.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -3385,11 +3595,11 @@ function generateAll(rootDir) {
   const extras = [...byLayer.keys()].filter((l) => !wellKnownOrder.includes(l)).sort();
   return [...wellKnownOrder, ...extras].map((l) => byLayer.get(l)).filter((r) => !!r);
 }
-var import_node_fs12, import_node_path13;
+var import_node_fs13, import_node_path13;
 var init_graph_builder = __esm({
   "src/server/graph/core/graph-builder.ts"() {
     "use strict";
-    import_node_fs12 = require("node:fs");
+    import_node_fs13 = require("node:fs");
     import_node_path13 = require("node:path");
     init_config();
     init_parser_registry();
@@ -3436,11 +3646,11 @@ function detectConventionDirs(rootDir, extraConventionDirs = []) {
   for (const base of searchDirs) {
     for (const convention of conventionDirs) {
       const dir = (0, import_node_path14.join)(base, convention);
-      if (!(0, import_node_fs13.existsSync)(dir)) continue;
+      if (!(0, import_node_fs14.existsSync)(dir)) continue;
       try {
-        const stat = (0, import_node_fs13.statSync)(dir);
+        const stat = (0, import_node_fs14.statSync)(dir);
         if (!stat.isDirectory()) continue;
-        const entries = (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+        const entries = (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
         if (entries.length > 0) {
           const relPath = dir.replace(rootDir + "/", "").replace(rootDir + "\\", "");
           result.set(relPath, entries);
@@ -3512,11 +3722,11 @@ function extractModuleFromPath(id, extraTrivial, extraSkipSegments) {
   }
   return "root";
 }
-var import_node_fs13, import_node_path14, CONVENTION_DIRS_BUILTIN, GENERIC_ROLE_NAMES_BUILTIN, SKIP_SEGMENTS_BUILTIN, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
+var import_node_fs14, import_node_path14, CONVENTION_DIRS_BUILTIN, GENERIC_ROLE_NAMES_BUILTIN, SKIP_SEGMENTS_BUILTIN, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
 var init_module_tagger = __esm({
   "src/server/graph/taggers/module-tagger.ts"() {
     "use strict";
-    import_node_fs13 = require("node:fs");
+    import_node_fs14 = require("node:fs");
     import_node_path14 = require("node:path");
     CONVENTION_DIRS_BUILTIN = ["features", "modules", "domains", "areas"];
     GENERIC_ROLE_NAMES_BUILTIN = /* @__PURE__ */ new Set([
@@ -3786,14 +3996,14 @@ function tagsFilePath(rootDir) {
 }
 function readTagStore(rootDir) {
   const filePath = tagsFilePath(rootDir);
-  if (!(0, import_node_fs14.existsSync)(filePath)) return {};
-  const stat = (0, import_node_fs14.statSync)(filePath);
+  if (!(0, import_node_fs15.existsSync)(filePath)) return {};
+  const stat = (0, import_node_fs15.statSync)(filePath);
   const cached = tagCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.store;
   }
   try {
-    const content = (0, import_node_fs14.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
     const store = JSON.parse(content);
     tagCache.set(filePath, { mtimeMs: stat.mtimeMs, store });
     return store;
@@ -3804,14 +4014,14 @@ function readTagStore(rootDir) {
 function writeTagStore(rootDir, store) {
   const filePath = tagsFilePath(rootDir);
   const dir = (0, import_node_path16.dirname)(filePath);
-  (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs15.mkdirSync)(dir, { recursive: true });
   const cleaned = {};
   for (const [nodeId, tags] of Object.entries(store)) {
     if (Object.keys(tags).length > 0) {
       cleaned[nodeId] = tags;
     }
   }
-  (0, import_node_fs14.writeFileSync)(filePath, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
+  (0, import_node_fs15.writeFileSync)(filePath, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
   tagCache.delete(filePath);
 }
 function setTag(rootDir, nodeId, key, value) {
@@ -3829,11 +4039,11 @@ function removeTag(rootDir, nodeId, key) {
   }
   writeTagStore(rootDir, store);
 }
-var import_node_fs14, import_node_path16, TAGS_FILENAME, GRAPHS_DIR, tagCache;
+var import_node_fs15, import_node_path16, TAGS_FILENAME, GRAPHS_DIR, tagCache;
 var init_tag_store = __esm({
   "src/server/graph/core/tag-store.ts"() {
     "use strict";
-    import_node_fs14 = require("node:fs");
+    import_node_fs15 = require("node:fs");
     import_node_path16 = require("node:path");
     TAGS_FILENAME = "tags.json";
     GRAPHS_DIR = ".launchsecure/graphs";
@@ -3844,8 +4054,8 @@ var init_tag_store = __esm({
 // src/server/graph/index.ts
 function getAvailableLayers(rootDir) {
   const dir = (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
-  if (!(0, import_node_fs15.existsSync)(dir)) return [];
-  return (0, import_node_fs15.readdirSync)(dir).filter((f) => f.endsWith(".json") && f !== "tags.json").map((f) => f.replace(".json", ""));
+  if (!(0, import_node_fs16.existsSync)(dir)) return [];
+  return (0, import_node_fs16.readdirSync)(dir).filter((f) => f.endsWith(".json") && f !== "tags.json").map((f) => f.replace(".json", ""));
 }
 function graphsDir(rootDir) {
   return (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
@@ -3857,8 +4067,8 @@ function tagsFilePath2(rootDir) {
   return (0, import_node_path17.join)(graphsDir(rootDir), "tags.json");
 }
 function getMtimeMs(filePath) {
-  if (!(0, import_node_fs15.existsSync)(filePath)) return 0;
-  return (0, import_node_fs15.statSync)(filePath).mtimeMs;
+  if (!(0, import_node_fs16.existsSync)(filePath)) return 0;
+  return (0, import_node_fs16.statSync)(filePath).mtimeMs;
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
@@ -3897,20 +4107,20 @@ function applyTags(graph, layer, rootDir) {
 }
 function readGraphRaw(rootDir, layer) {
   const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs15.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs15.statSync)(filePath);
+  if (!(0, import_node_fs16.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs16.statSync)(filePath);
   const cached = graphCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.graph;
   }
-  const content = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs16.readFileSync)(filePath, "utf-8");
   const graph = JSON.parse(content);
   graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
   return graph;
 }
 function readGraph(rootDir, layer) {
   const rawFilePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs15.existsSync)(rawFilePath)) return null;
+  if (!(0, import_node_fs16.existsSync)(rawFilePath)) return null;
   const rawMtime = getMtimeMs(rawFilePath);
   const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
   const cacheKey = `${rootDir}:${layer}`;
@@ -3940,21 +4150,21 @@ async function generateGraph(rootDir, layer) {
     mutationMethods: config.parsers?.patterns?.mutationMethods
   });
   const dir = graphsDir(rootDir);
-  (0, import_node_fs15.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs16.mkdirSync)(dir, { recursive: true });
   const results = layer ? [generateLayer(rootDir, layer)].filter((r) => r !== null) : generateAll(rootDir);
   for (const result of results) {
     const filePath = graphFilePath(rootDir, result.layer);
-    (0, import_node_fs15.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    (0, import_node_fs16.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
     invalidateCache(filePath);
     invalidateTaggedCache(rootDir, result.layer);
   }
   return results;
 }
-var import_node_fs15, import_node_path17, GRAPHS_DIR2, graphCache, taggedCache;
+var import_node_fs16, import_node_path17, GRAPHS_DIR2, graphCache, taggedCache;
 var init_graph = __esm({
   "src/server/graph/index.ts"() {
     "use strict";
-    import_node_fs15 = require("node:fs");
+    import_node_fs16 = require("node:fs");
     import_node_path17 = require("node:path");
     init_graph_builder();
     init_config();
@@ -3971,9 +4181,9 @@ var init_graph = __esm({
 // src/server/graph/core/audit-core.ts
 function readGraphFile(rootDir, layer) {
   const filePath = (0, import_node_path18.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
-  if (!(0, import_node_fs16.existsSync)(filePath)) return null;
+  if (!(0, import_node_fs17.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs16.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs17.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -4019,8 +4229,8 @@ function checkUnprotectedRoutes(rootDir) {
   if (!api) return buildReport("api", "unprotected_routes", findings);
   const routePermsPath = (0, import_node_path18.join)(rootDir, "src", "config", "route-permissions.ts");
   let routePermsContent = "";
-  if ((0, import_node_fs16.existsSync)(routePermsPath)) {
-    routePermsContent = (0, import_node_fs16.readFileSync)(routePermsPath, "utf-8");
+  if ((0, import_node_fs17.existsSync)(routePermsPath)) {
+    routePermsContent = (0, import_node_fs17.readFileSync)(routePermsPath, "utf-8");
   }
   const registeredRoutes = /* @__PURE__ */ new Set();
   const routeEntryRe = /path:\s*'([^']+)'/g;
@@ -4099,8 +4309,8 @@ function checkUnenforcedPermissions(rootDir) {
   const permissions = staticGraph.nodes.filter((n) => n.type === "seed_permission").map((n) => ({ id: n.id, key: n.value, name: n.name }));
   const routePermsPath = (0, import_node_path18.join)(rootDir, "src", "config", "route-permissions.ts");
   let routePermsContent = "";
-  if ((0, import_node_fs16.existsSync)(routePermsPath)) {
-    routePermsContent = (0, import_node_fs16.readFileSync)(routePermsPath, "utf-8");
+  if ((0, import_node_fs17.existsSync)(routePermsPath)) {
+    routePermsContent = (0, import_node_fs17.readFileSync)(routePermsPath, "utf-8");
   }
   for (const perm of permissions) {
     const regex = new RegExp(`permission:\\s*['"]${perm.key}['"]`);
@@ -4131,8 +4341,8 @@ function checkHardcodedValues(rootDir) {
   for (const node of api.nodes) {
     if (node.type !== "endpoint") continue;
     const filePath = (0, import_node_path18.join)(rootDir, "src", node.id);
-    if (!(0, import_node_fs16.existsSync)(filePath)) continue;
-    const content = (0, import_node_fs16.readFileSync)(filePath, "utf-8");
+    if (!(0, import_node_fs17.existsSync)(filePath)) continue;
+    const content = (0, import_node_fs17.readFileSync)(filePath, "utf-8");
     let m;
     allCapsRe.lastIndex = 0;
     while ((m = allCapsRe.exec(content)) !== null) {
@@ -4226,11 +4436,11 @@ function formatAsPrompt(reports) {
   if (lines.length === 0) return "No audit findings.";
   return lines.join("\n");
 }
-var import_node_fs16, import_node_path18, CHECKS;
+var import_node_fs17, import_node_path18, CHECKS;
 var init_audit_core = __esm({
   "src/server/graph/core/audit-core.ts"() {
     "use strict";
-    import_node_fs16 = require("node:fs");
+    import_node_fs17 = require("node:fs");
     import_node_path18 = require("node:path");
     CHECKS = {
       db: {
@@ -4264,14 +4474,14 @@ function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
     const graphsDir2 = import_node_path19.default.join(dir, ".launchsecure", "graphs");
-    if (import_node_fs17.default.existsSync(import_node_path19.default.join(graphsDir2, "ui.json")) || import_node_fs17.default.existsSync(import_node_path19.default.join(graphsDir2, "api.json")) || import_node_fs17.default.existsSync(import_node_path19.default.join(graphsDir2, "db.json"))) return dir;
+    if (import_node_fs18.default.existsSync(import_node_path19.default.join(graphsDir2, "ui.json")) || import_node_fs18.default.existsSync(import_node_path19.default.join(graphsDir2, "api.json")) || import_node_fs18.default.existsSync(import_node_path19.default.join(graphsDir2, "db.json"))) return dir;
     const parent = import_node_path19.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs17.default.existsSync(import_node_path19.default.join(dir, ".git"))) return dir;
+    if (import_node_fs18.default.existsSync(import_node_path19.default.join(dir, ".git"))) return dir;
     const parent = import_node_path19.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -4332,16 +4542,16 @@ async function buildMergedGraph(root) {
   };
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs17.default.existsSync(filePath) || !import_node_fs17.default.statSync(filePath).isFile()) return false;
+  if (!import_node_fs18.default.existsSync(filePath) || !import_node_fs18.default.statSync(filePath).isFile()) return false;
   const ext = import_node_path19.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs17.default.createReadStream(filePath).pipe(res);
+  import_node_fs18.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
   const indexPath = import_node_path19.default.join(clientDir, "index.html");
-  if (!import_node_fs17.default.existsSync(indexPath)) {
+  if (!import_node_fs18.default.existsSync(indexPath)) {
     res.writeHead(500, { "Content-Type": "text/plain" });
     res.end(`LaunchChart client bundle not found at ${clientDir}. Run 'npm run build:chart-client'.`);
     return;
@@ -4349,14 +4559,14 @@ function serveIndex(res, clientDir) {
   serveStatic(res, indexPath);
 }
 function tryListen(server, port) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const onError = (err2) => {
       server.off("listening", onListening);
       reject(err2);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve3(port);
+      resolve4(port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -4410,10 +4620,10 @@ async function startChartServer(opts = {}) {
       if (req.method === "GET" && url2.pathname === "/api/projects") {
         const projectList = projects.length > 0 ? projects.map((p) => {
           const absRoot = import_node_path19.default.resolve(projectRoot, p.root);
-          const hasGraphs = import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, ".launchsecure", "graphs"));
-          const hasNextConfig2 = import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, "next.config.ts")) || import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, "next.config.js")) || import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, "next.config.mjs"));
-          return { name: p.name, root: p.root, hasGraphs, hasNextConfig: hasNextConfig2 };
-        }) : [{ name: import_node_path19.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs17.default.existsSync(import_node_path19.default.join(projectRoot, ".launchsecure", "graphs")), hasNextConfig: true }];
+          const hasGraphs = import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, ".launchsecure", "graphs"));
+          const hasNextConfig = import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, "next.config.ts")) || import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, "next.config.js")) || import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, "next.config.mjs"));
+          return { name: p.name, root: p.root, hasGraphs, hasNextConfig };
+        }) : [{ name: import_node_path19.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs18.default.existsSync(import_node_path19.default.join(projectRoot, ".launchsecure", "graphs")), hasNextConfig: true }];
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ projects: projectList, monorepoRoot: projectRoot }));
         return;
@@ -4465,14 +4675,14 @@ async function startChartServer(opts = {}) {
           return;
         }
         const filePath = import_node_path19.default.join(reqRoot, relPath);
-        if (!filePath.startsWith(reqRoot) || !import_node_fs17.default.existsSync(filePath) || !import_node_fs17.default.statSync(filePath).isFile()) {
+        if (!filePath.startsWith(reqRoot) || !import_node_fs18.default.existsSync(filePath) || !import_node_fs18.default.statSync(filePath).isFile()) {
           res.writeHead(404, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "File not found" }));
           return;
         }
         const ext = import_node_path19.default.extname(filePath).toLowerCase();
         const langMap = { ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx", ".prisma": "prisma", ".json": "json", ".css": "css" };
-        const content = import_node_fs17.default.readFileSync(filePath, "utf-8");
+        const content = import_node_fs18.default.readFileSync(filePath, "utf-8");
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ content, language: langMap[ext] ?? "text", path: relPath }));
         return;
@@ -4515,7 +4725,7 @@ async function startChartServer(opts = {}) {
           try {
             const newConfig = JSON.parse(body);
             const configPath = import_node_path19.default.join(reqRoot, ".launchchart.json");
-            import_node_fs17.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            import_node_fs18.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
           } catch (err2) {
@@ -4549,7 +4759,7 @@ async function startChartServer(opts = {}) {
             const config2 = loadConfig(reqRoot);
             config2.taggers = taggerConfig;
             const configPath = import_node_path19.default.join(reqRoot, ".launchchart.json");
-            import_node_fs17.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+            import_node_fs18.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
           } catch (err2) {
@@ -4616,16 +4826,23 @@ async function startChartServer(opts = {}) {
         const paths = resolveProjectPaths(reqRoot, config2);
         const overrides = {
           appDir: !!config2.paths?.appDir,
-          dbDir: !!config2.paths?.dbDir
+          dbDir: !!config2.paths?.dbDir,
+          srcRoots: !!(config2.paths?.srcRoots && config2.paths.srcRoots.length > 0)
         };
+        const relFromRoot = (abs) => import_node_path19.default.relative(reqRoot, abs) || ".";
         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),
-            dbDir: paths.dbDir ? import_node_path19.default.relative(reqRoot, paths.dbDir) : null
+            srcDir: relFromRoot(paths.srcDir),
+            appDir: relFromRoot(paths.appDir),
+            apiDir: relFromRoot(paths.apiDir),
+            dbDir: paths.dbDir ? relFromRoot(paths.dbDir) : null,
+            dbKind: paths.dbConfig.kind,
+            dbSchemaPath: paths.dbConfig.schemaPath ? relFromRoot(paths.dbConfig.schemaPath) : null,
+            dbMigrationsDir: paths.dbConfig.migrationsDir ? relFromRoot(paths.dbConfig.migrationsDir) : null,
+            srcRoots: paths.srcRoots.map(relFromRoot),
+            conventionFiles: paths.conventionFiles.map(relFromRoot)
           } : null,
           overrides,
           isOverride: overrides.appDir
@@ -4642,7 +4859,7 @@ async function startChartServer(opts = {}) {
           return;
         }
         try {
-          const entries = import_node_fs17.default.readdirSync(abs, { withFileTypes: true });
+          const entries = import_node_fs18.default.readdirSync(abs, { withFileTypes: true });
           const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist" && e.name !== ".next").map((e) => e.name).sort();
           const parent = abs !== twoUp ? import_node_path19.default.dirname(abs) : null;
           res.writeHead(200, { "Content-Type": "application/json" });
@@ -4673,7 +4890,7 @@ async function startChartServer(opts = {}) {
             const config2 = loadConfig(projectRoot);
             config2.projects = newProjects.length > 0 ? newProjects : void 0;
             const configPath = import_node_path19.default.join(projectRoot, ".launchchart.json");
-            import_node_fs17.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+            import_node_fs18.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
             projects.length = 0;
             if (config2.projects) projects.push(...config2.projects);
             res.writeHead(200, { "Content-Type": "application/json" });
@@ -4746,12 +4963,12 @@ function runServeCli(argv) {
     process.exit(1);
   });
 }
-var import_node_http, import_node_fs17, import_node_path19, MAX_PORT_SCAN, MIME_TYPES;
+var import_node_http, import_node_fs18, import_node_path19, MAX_PORT_SCAN, MIME_TYPES;
 var init_chart_serve = __esm({
   "src/server/chart-serve.ts"() {
     "use strict";
     import_node_http = __toESM(require("node:http"));
-    import_node_fs17 = __toESM(require("node:fs"));
+    import_node_fs18 = __toESM(require("node:fs"));
     import_node_path19 = __toESM(require("node:path"));
     init_graph();
     init_lockfile();
@@ -4774,214 +4991,6 @@ var init_chart_serve = __esm({
   }
 });
 
-// src/server/blast-radius-builder.ts
-function loadDefaults(rootDir) {
-  const filePath = (0, import_node_path20.join)(rootDir, ".launchsecure", "blast-radius-defaults.json");
-  try {
-    if (import_node_fs18.default.existsSync(filePath)) {
-      const raw = import_node_fs18.default.readFileSync(filePath, "utf-8");
-      return JSON.parse(raw);
-    }
-  } catch {
-  }
-  return FALLBACK_DEFAULTS;
-}
-function generateAcceptance(node, inspect) {
-  const criteria = [];
-  const t = node.type?.toLowerCase() ?? "";
-  if (t === "endpoint" || t === "mcp-tool") {
-    const methods = inspect?.methods ?? [];
-    const path3 = inspect?.path ?? node.id;
-    if (methods.length > 0) {
-      criteria.push(`${methods.join("/")} ${path3} still returns correct responses for authorized users`);
-    } else {
-      criteria.push(`${path3} still responds correctly`);
-    }
-    if (inspect?.auth && inspect.auth.includes("withAuth")) {
-      criteria.push("Authentication and authorization still enforced");
-    }
-    if (inspect?.db_models && inspect.db_models.length > 0) {
-      criteria.push(`DB operations on ${inspect.db_models.join(", ")} still work correctly`);
-    }
-  } else if (t === "page" || t === "component" || t === "layout") {
-    criteria.push(`${node.name} renders without errors`);
-    if (inspect?.stateVars && inspect.stateVars.length > 0) {
-      criteria.push("State management still works correctly");
-    }
-    if (inspect?.elements && inspect.elements.length > 5) {
-      criteria.push("All child components render correctly");
-    }
-  } else if (t === "table" || t === "enum") {
-    criteria.push(`${node.name} schema unchanged or migration applies cleanly`);
-    criteria.push("Existing queries against this table still work");
-  } else if (t === "hook") {
-    criteria.push(`${node.name} returns expected shape`);
-    if (inspect?.stateVars && inspect.stateVars.length > 0) {
-      criteria.push(`State variables [${inspect.stateVars.map((s) => s.name).join(", ")}] still returned`);
-    }
-  } else if (t === "context") {
-    criteria.push(`${node.name} provides correct context to consumers`);
-  } else if (t === "lib" || t === "config" || t === "types") {
-    criteria.push(`${node.name} exports still conform to expected interface`);
-  } else if (t === "seed" || t === "seed_role" || t === "seed_permission") {
-    criteria.push("Seed runs without errors");
-    criteria.push("Expected rows created in database");
-  } else {
-    criteria.push("Verify no regression");
-  }
-  return criteria;
-}
-function buildManifest(input) {
-  const { mode, title, description, subtitle, blastResults, createNodes, inspectData, defaults } = input;
-  const nodeMap = /* @__PURE__ */ new Map();
-  const centerNodeIds = /* @__PURE__ */ new Set();
-  for (const result of blastResults) {
-    centerNodeIds.add(result.center.id);
-    for (const node of result.affected) {
-      const existing = nodeMap.get(node.id);
-      if (!existing || node.hop < existing.hop) {
-        nodeMap.set(node.id, node);
-      }
-    }
-  }
-  for (const id of centerNodeIds) {
-    nodeMap.delete(id);
-  }
-  const manifestNodes = [];
-  for (const result of blastResults) {
-    const c = result.center;
-    if (manifestNodes.some((n) => n.id === c.id)) continue;
-    const inspect = inspectData[c.id];
-    manifestNodes.push({
-      id: c.id,
-      name: c.name,
-      layer: c.layer,
-      ring: "modify",
-      type: c.type,
-      reason: `Direct change target`,
-      acceptance: generateAcceptance(
-        { id: c.id, name: c.name, type: c.type, layer: c.layer, hop: 0 },
-        inspect
-      )
-    });
-  }
-  for (const [, node] of nodeMap) {
-    const ring = node.hop <= 1 ? "modify" : "ripple";
-    const inspect = inspectData[node.id];
-    const reason = node.hop <= 1 ? `Directly depends on changed node` : `Indirect dependency (${node.hop} hops away)`;
-    manifestNodes.push({
-      id: node.id,
-      name: node.name,
-      layer: node.layer,
-      ring,
-      type: node.type,
-      reason,
-      acceptance: generateAcceptance(node, inspect)
-    });
-  }
-  for (const cn of createNodes) {
-    manifestNodes.push({
-      id: cn.id,
-      name: cn.name,
-      layer: cn.layer,
-      ring: "create",
-      type: cn.type ?? "unknown",
-      reason: cn.reason,
-      acceptance: cn.acceptance ?? ["Verify implementation matches spec"]
-    });
-  }
-  const layerIds = /* @__PURE__ */ new Set();
-  for (const n of manifestNodes) {
-    layerIds.add(n.layer);
-  }
-  const layers = [];
-  for (const id of layerIds) {
-    const def = defaults.layers[id];
-    if (def) {
-      layers.push({ id, name: def.name, icon: def.icon, color: def.color });
-    } else {
-      layers.push({ id, name: id, icon: "box", color: "#cbd5e1" });
-    }
-  }
-  const edgeSet = /* @__PURE__ */ new Set();
-  const edges = [];
-  const allNodeIds = new Set(manifestNodes.map((n) => n.id));
-  for (const cId of centerNodeIds) {
-    for (const result of blastResults) {
-      for (const affected of result.affected) {
-        if (affected.hop === 1 && result.center.id === cId && allNodeIds.has(affected.id)) {
-          const key = `${cId}->${affected.id}`;
-          if (!edgeSet.has(key)) {
-            edgeSet.add(key);
-            edges.push({ source: cId, target: affected.id });
-          }
-        }
-      }
-    }
-  }
-  for (const result of blastResults) {
-    if (result.edges) {
-      for (const edge of result.edges) {
-        if (allNodeIds.has(edge.source) && allNodeIds.has(edge.target)) {
-          const key = `${edge.source}->${edge.target}`;
-          if (!edgeSet.has(key)) {
-            edgeSet.add(key);
-            edges.push({ source: edge.source, target: edge.target });
-          }
-        }
-      }
-    }
-  }
-  for (const cn of createNodes) {
-    edges.push({ source: "center", target: cn.id });
-    if (cn.connects_to) {
-      for (const targetId of cn.connects_to) {
-        if (allNodeIds.has(targetId) || createNodes.some((c) => c.id === targetId)) {
-          const key = `${cn.id}->${targetId}`;
-          if (!edgeSet.has(key)) {
-            edgeSet.add(key);
-            edges.push({ source: cn.id, target: targetId });
-          }
-        }
-      }
-    }
-  }
-  return {
-    mode,
-    title,
-    subtitle,
-    layers,
-    rings: defaults.rings,
-    center: { name: title, description },
-    nodes: manifestNodes,
-    edges
-  };
-}
-var import_node_fs18, import_node_path20, FALLBACK_DEFAULTS;
-var init_blast_radius_builder = __esm({
-  "src/server/blast-radius-builder.ts"() {
-    "use strict";
-    import_node_fs18 = __toESM(require("node:fs"));
-    import_node_path20 = require("node:path");
-    FALLBACK_DEFAULTS = {
-      rings: [
-        { id: "modify", name: "Modify", color: "#ff6b00" },
-        { id: "ripple", name: "Ripple (verify)", color: "#ffff00" },
-        { id: "create", name: "Create", color: "#00ff00" }
-      ],
-      layers: {
-        db: { name: "Database", icon: "database", color: "#cbd5e1" },
-        api: { name: "API", icon: "server", color: "#cbd5e1" },
-        middleware: { name: "Middleware", icon: "shield", color: "#cbd5e1" },
-        ui: { name: "UI", icon: "layout-dashboard", color: "#cbd5e1" },
-        config: { name: "Config / Seed", icon: "settings", color: "#cbd5e1" },
-        shared: { name: "Shared Types", icon: "box", color: "#cbd5e1" }
-      },
-      center: { color: "#ff0000" }
-    };
-  }
-});
-
 // src/server/graph/core/language-detection.ts
 function walkForExtensions(dir, extCounts, depth = 0) {
   if (depth > 10) return;
@@ -4996,9 +5005,9 @@ function walkForExtensions(dir, extCounts, depth = 0) {
     if (entry.name.startsWith(".") && entry.isDirectory()) continue;
     if (entry.isDirectory()) {
       if (IGNORE_DIRS.has(entry.name)) continue;
-      walkForExtensions((0, import_node_path21.join)(dir, entry.name), extCounts, depth + 1);
+      walkForExtensions((0, import_node_path20.join)(dir, entry.name), extCounts, depth + 1);
     } else {
-      const ext = (0, import_node_path21.extname)(entry.name).toLowerCase();
+      const ext = (0, import_node_path20.extname)(entry.name).toLowerCase();
       if (ext && EXTENSION_TO_LANGUAGE[ext]) {
         extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
       }
@@ -5037,12 +5046,12 @@ function detectLanguages(rootDir, supportedLanguages) {
   });
   return results;
 }
-var import_node_fs19, import_node_path21, EXTENSION_TO_LANGUAGE, IGNORE_DIRS, AUXILIARY_LANGUAGES;
+var import_node_fs19, import_node_path20, EXTENSION_TO_LANGUAGE, IGNORE_DIRS, AUXILIARY_LANGUAGES;
 var init_language_detection = __esm({
   "src/server/graph/core/language-detection.ts"() {
     "use strict";
     import_node_fs19 = require("node:fs");
-    import_node_path21 = require("node:path");
+    import_node_path20 = require("node:path");
     EXTENSION_TO_LANGUAGE = {
       // Web / Frontend
       ".ts": "typescript",
@@ -5375,144 +5384,6 @@ function handleBlastPoints(args) {
     }
   });
 }
-function handleGenerateBlastRadius(args) {
-  const rootDir = process.cwd();
-  const mode = args.mode ?? "structural";
-  const title = args.title;
-  const description = args.description ?? title;
-  const subtitle = args.subtitle;
-  const hops = args.hops ?? 2;
-  const defaults = loadDefaults(rootDir);
-  let centerNodeIds = [];
-  if (mode === "structural") {
-    const nodeId = args.node_id;
-    if (!nodeId) return err("structural mode requires node_id");
-    centerNodeIds = [nodeId];
-  } else {
-    centerNodeIds = args.center_nodes ?? [];
-    if (centerNodeIds.length === 0) return err("feature mode requires center_nodes[]");
-  }
-  const createNodes = args.create_nodes ?? [];
-  const blastResults = [];
-  for (const nodeId of centerNodeIds) {
-    let 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) continue;
-    const graph = readGraph(rootDir, targetLayer);
-    if (!graph) continue;
-    const center = graph.nodes.find((n) => n.id === nodeId);
-    if (!center) continue;
-    const result2 = reverseNeighborhood(graph, nodeId, hops, "reverse");
-    const affected = [];
-    for (const [id, { node, hop }] of result2.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 centerTags = center.tags;
-    const edges = result2.edges.map((e) => ({ source: e.source, target: e.target }));
-    blastResults.push({
-      center: { id: center.id, name: center.name, type: center.type, layer: targetLayer, module: centerTags?.module },
-      affected,
-      edges
-    });
-  }
-  if (blastResults.length === 0) {
-    return err(`None of the center nodes were found in any graph layer: ${centerNodeIds.join(", ")}`);
-  }
-  const inspectData = {};
-  const allAffectedIds = /* @__PURE__ */ new Set();
-  for (const r of blastResults) {
-    allAffectedIds.add(r.center.id);
-    for (const a of r.affected) allAffectedIds.add(a.id);
-  }
-  const allGraphs = readAllGraphs(rootDir);
-  for (const id of allAffectedIds) {
-    for (const [, graph] of Object.entries(allGraphs)) {
-      if (!graph) continue;
-      const node = graph.nodes.find((n) => n.id === id);
-      if (node) {
-        inspectData[id] = {
-          type: node.type,
-          name: node.name,
-          methods: node.methods,
-          path: node.path ?? node.handler,
-          auth: node.auth,
-          db_models: node.db_models
-        };
-        break;
-      }
-    }
-  }
-  const manifest = buildManifest({
-    mode,
-    title,
-    description,
-    subtitle,
-    blastResults,
-    createNodes,
-    inspectData,
-    defaults
-  });
-  const pushToDeck = args.push_to_deck;
-  const session = args.session;
-  let deckResult;
-  if (pushToDeck) {
-    if (!session) return err("push_to_deck requires a session name");
-    const deckLockPath = (0, import_node_path22.join)(rootDir, ".launchsecure", "launch-deck.lock");
-    if (!(0, import_node_fs20.existsSync)(deckLockPath)) {
-      deckResult = { pushed: false, reason: "Deck server not running (no lock file). Push manually via deck tool." };
-    } else {
-      try {
-        const lock = JSON.parse((0, import_node_fs20.readFileSync)(deckLockPath, "utf-8"));
-        const deckUrl = lock.url;
-        const body = JSON.stringify({
-          session,
-          mode: "show",
-          blocks: [{ type: "blast-radius", label: title, manifest }]
-        });
-        (0, import_node_child_process2.execFileSync)("curl", [
-          "-s",
-          "-X",
-          "POST",
-          deckUrl + "/api/deck",
-          "-H",
-          "Content-Type: application/json",
-          "-d",
-          body
-        ], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] });
-        deckResult = { pushed: true, session, url: deckUrl };
-      } catch (e) {
-        deckResult = { pushed: false, reason: `Failed to push to deck: ${e}` };
-      }
-    }
-  }
-  const result = { ...manifest };
-  if (deckResult) result._deck = deckResult;
-  return okJson(result);
-}
 function layerSummary(graph) {
   const typeCounts = {};
   const moduleCounts = {};
@@ -5741,11 +5612,11 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui" || layer === "api") return (0, import_node_path22.join)(rootDir, "src", nodeId);
-  if (layer === "db") return (0, import_node_path22.join)(rootDir, "prisma", "schema.prisma");
-  const withSrc = (0, import_node_path22.join)(rootDir, "src", nodeId);
+  if (layer === "ui" || layer === "api") return (0, import_node_path21.join)(rootDir, "src", nodeId);
+  if (layer === "db") return (0, import_node_path21.join)(rootDir, "prisma", "schema.prisma");
+  const withSrc = (0, import_node_path21.join)(rootDir, "src", nodeId);
   if ((0, import_node_fs20.existsSync)(withSrc)) return withSrc;
-  const direct = (0, import_node_path22.join)(rootDir, nodeId);
+  const direct = (0, import_node_path21.join)(rootDir, nodeId);
   if ((0, import_node_fs20.existsSync)(direct)) return direct;
   return null;
 }
@@ -5958,9 +5829,9 @@ function handleStartChartServer(args) {
     });
   }
   const entryPath = process.argv[1];
-  const logDir = (0, import_node_path22.join)((0, import_node_os2.homedir)(), ".launchsecure");
+  const logDir = (0, import_node_path21.join)((0, import_node_os2.homedir)(), ".launchsecure");
   (0, import_node_fs20.mkdirSync)(logDir, { recursive: true });
-  const logPath = (0, import_node_path22.join)(logDir, "launch-chart.log");
+  const logPath = (0, import_node_path21.join)(logDir, "launch-chart.log");
   const out = (0, import_node_fs20.openSync)(logPath, "a");
   const err2 = (0, import_node_fs20.openSync)(logPath, "a");
   const portArgs = args.port ? ["--port", String(args.port)] : [];
@@ -6082,18 +5953,18 @@ function handleDetectProjectStack() {
       if (ref.type === "references_api") stats.references_api++;
     }
   }
-  const srcDir = (0, import_node_path22.join)(rootDir, "src");
+  const srcDir = (0, import_node_path21.join)(rootDir, "src");
   if ((0, import_node_fs20.existsSync)(srcDir)) {
     const scanDir = (dir) => {
       if (!(0, import_node_fs20.existsSync)(dir)) return;
       for (const entry of (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true })) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        const full = (0, import_node_path22.join)(dir, entry.name);
+        const full = (0, import_node_path21.join)(dir, entry.name);
         if (entry.isDirectory()) {
           scanDir(full);
           continue;
         }
-        if (![".ts", ".tsx"].includes((0, import_node_path22.extname)(entry.name))) continue;
+        if (![".ts", ".tsx"].includes((0, import_node_path21.extname)(entry.name))) continue;
         try {
           const content = (0, import_node_fs20.readFileSync)(full, "utf-8");
           const matches = content.match(/@api\s+(GET|POST|PUT|DELETE|PATCH)\s+\/\S+/g);
@@ -6214,10 +6085,6 @@ async function handleMessage(msg) {
       respond(id ?? null, handleBlastPoints(args));
       return;
     }
-    if (toolName === "generate_blast_radius") {
-      respond(id ?? null, handleGenerateBlastRadius(args));
-      return;
-    }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
     return;
   }
@@ -6253,16 +6120,15 @@ function startGraphMcpServer() {
   process.stderr.write(`[launchsecure-graph] MCP server started (cwd: ${process.cwd()})
 `);
 }
-var import_node_fs20, import_node_path22, import_node_child_process2, import_node_os2, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, DEEP_FIELDS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, DEFAULT_EST_NODE_FULL, DEFAULT_EST_NODE_MIN, DEFAULT_EST_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
+var import_node_fs20, import_node_path21, import_node_child_process2, import_node_os2, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, DEEP_FIELDS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, DEFAULT_EST_NODE_FULL, DEFAULT_EST_NODE_MIN, DEFAULT_EST_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
 var init_graph_mcp = __esm({
   "src/server/graph-mcp.ts"() {
     "use strict";
     import_node_fs20 = require("node:fs");
-    import_node_path22 = require("node:path");
+    import_node_path21 = require("node:path");
     import_node_child_process2 = require("node:child_process");
     import_node_os2 = require("node:os");
     init_graph();
-    init_blast_radius_builder();
     init_lockfile();
     init_config();
     init_parser_registry();
@@ -6579,81 +6445,6 @@ Example: blast_points(node_id: "server/auth/middleware.ts", hops: 2) \u2192 retu
           },
           required: ["node_id"]
         }
-      },
-      {
-        name: "generate_blast_radius",
-        description: `Generate a complete BlastRadiusManifest from graph data \u2014 ready to push to deck.
-
-Two modes:
-- **Structural**: single node changed \u2192 auto-discover what's affected via reverse BFS
-  Example: generate_blast_radius({ mode: "structural", node_id: "CommentChannel", title: "CommentChannel refactor" })
-- **Feature**: new feature \u2192 multiple starting nodes + new nodes to create
-  Example: generate_blast_radius({ mode: "feature", title: "Client Role", description: "...", center_nodes: ["CommentChannel", "ProjectMember"], create_nodes: [{ id: "ChannelMember", name: "ChannelMember table", layer: "db", reason: "..." }] })
-
-Output is a BlastRadiusManifest JSON that passes directly to the deck tool's blast-radius block.
-Reads ring/layer/center colors from .launchsecure/blast-radius-defaults.json.
-Auto-generates acceptance criteria per node using inspect_node AST data.`,
-        inputSchema: {
-          type: "object",
-          properties: {
-            mode: {
-              type: "string",
-              enum: ["structural", "feature"],
-              description: '"structural" = single node changed. "feature" = new feature with multiple nodes.'
-            },
-            title: {
-              type: "string",
-              description: "Title for the blast radius (shown in center node and header)."
-            },
-            description: {
-              type: "string",
-              description: "Description of the change or feature."
-            },
-            subtitle: {
-              type: "string",
-              description: "Optional subtitle shown above title in the viz."
-            },
-            node_id: {
-              type: "string",
-              description: "Structural mode only: the node being changed."
-            },
-            center_nodes: {
-              type: "array",
-              items: { type: "string" },
-              description: "Feature mode: existing graph node IDs that are the starting points for traversal."
-            },
-            create_nodes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  id: { type: "string" },
-                  name: { type: "string" },
-                  layer: { type: "string" },
-                  type: { type: "string" },
-                  reason: { type: "string" },
-                  acceptance: { type: "array", items: { type: "string" } },
-                  connects_to: { type: "array", items: { type: "string" }, description: "IDs of existing nodes this new node has FK/relationship edges to." }
-                },
-                required: ["id", "name", "layer", "reason"]
-              },
-              description: "Feature mode: new nodes that need to be created (not in graph yet)."
-            },
-            hops: {
-              type: "number",
-              description: "Max hops for traversal. Default 2. Hop 1 = modify ring, hop 2+ = ripple ring."
-            },
-            push_to_deck: {
-              type: "boolean",
-              description: "If true, pushes the manifest directly to LaunchDeck browser (requires deck server running). Default false."
-            },
-            session: {
-              type: "string",
-              description: "Session name for the deck tab. Required when push_to_deck is true."
-            }
-          },
-          required: ["title"]
-        }
       }
     ];
     COMPACT_SCHEMA = {
@@ -6721,7 +6512,7 @@ Auto-generates acceptance criteria per node using inspect_node AST data.`,
 // src/server/graph-mcp-entry.ts
 var import_node_child_process3 = require("node:child_process");
 var import_node_fs21 = require("node:fs");
-var import_node_path23 = __toESM(require("node:path"));
+var import_node_path22 = __toESM(require("node:path"));
 var import_node_os3 = require("node:os");
 var import_node_fs22 = require("node:fs");
 init_lockfile();
@@ -6739,9 +6530,9 @@ function maybeAutoServe() {
     return;
   }
   try {
-    const logDir = import_node_path23.default.join((0, import_node_os3.homedir)(), ".launchsecure");
+    const logDir = import_node_path22.default.join((0, import_node_os3.homedir)(), ".launchsecure");
     (0, import_node_fs22.mkdirSync)(logDir, { recursive: true });
-    const logPath = import_node_path23.default.join(logDir, "launch-chart.log");
+    const logPath = import_node_path22.default.join(logDir, "launch-chart.log");
     const out = (0, import_node_fs21.openSync)(logPath, "a");
     const err2 = (0, import_node_fs21.openSync)(logPath, "a");
     const entryPath = process.argv[1];