@launchsecure/launch-kit 0.0.4 → 0.0.6

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

@@ -29,17 +29,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/server/lockfile.ts
-function lockDir() {
+function lockDir(projectRoot) {
+  if (projectRoot) {
+    return (0, import_node_path.join)(projectRoot, ".launchsecure");
+  }
   return (0, import_node_path.join)((0, import_node_os.homedir)(), ".launchsecure");
 }
-function lockPath() {
-  return (0, import_node_path.join)(lockDir(), "launch-chart.lock");
+function lockPath(projectRoot) {
+  return (0, import_node_path.join)(lockDir(projectRoot), "launch-chart.lock");
 }
-function readLock() {
-  const p = lockPath();
-  if (!(0, import_node_fs.existsSync)(p)) return null;
+function readLock(projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
+  const p = lockPath(root);
+  if (!(0, import_node_fs.existsSync)(p)) {
+    if (root) {
+      const globalP = lockPath();
+      if ((0, import_node_fs.existsSync)(globalP)) {
+        try {
+          const data = JSON.parse((0, import_node_fs.readFileSync)(globalP, "utf-8"));
+          if (typeof data.pid === "number" && typeof data.port === "number" && data.cwd === root) {
+            return data;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
   try {
     const data = JSON.parse((0, import_node_fs.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
@@ -70,31 +89,35 @@ function getListenerPid(port) {
     return null;
   }
 }
-function getLiveLock() {
-  const lock = readLock();
+function getLiveLock(projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
+  const lock = readLock(root);
   if (!lock) return null;
   const listenerPid = getListenerPid(lock.port);
   const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
   if (!live) {
     try {
-      (0, import_node_fs.unlinkSync)(lockPath());
+      (0, import_node_fs.unlinkSync)(lockPath(root));
     } catch {
     }
     return null;
   }
   return lock;
 }
-function writeLock(data) {
-  (0, import_node_fs.mkdirSync)(lockDir(), { recursive: true });
-  (0, import_node_fs.writeFileSync)(lockPath(), JSON.stringify(data, null, 2) + "\n", "utf-8");
+function writeLock(data, projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
+  (0, import_node_fs.mkdirSync)(lockDir(root), { recursive: true });
+  (0, import_node_fs.writeFileSync)(lockPath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
+  if (root) _activeProjectRoot = root;
 }
-function clearLock() {
+function clearLock(projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
   try {
-    (0, import_node_fs.unlinkSync)(lockPath());
+    (0, import_node_fs.unlinkSync)(lockPath(root));
   } catch {
   }
 }
-var import_node_child_process, import_node_fs, import_node_os, import_node_path;
+var import_node_child_process, import_node_fs, import_node_os, import_node_path, _activeProjectRoot;
 var init_lockfile = __esm({
   "src/server/lockfile.ts"() {
     "use strict";
@@ -105,6 +128,30 @@ var init_lockfile = __esm({
   }
 });
 
+// src/server/graph/core/config.ts
+var config_exports = {};
+__export(config_exports, {
+  loadConfig: () => loadConfig
+});
+function loadConfig(rootDir) {
+  const configPath = (0, import_node_path2.join)(rootDir, CONFIG_FILENAME);
+  if (!(0, import_node_fs2.existsSync)(configPath)) return {};
+  try {
+    return JSON.parse((0, import_node_fs2.readFileSync)(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var import_node_fs2, import_node_path2, CONFIG_FILENAME;
+var init_config = __esm({
+  "src/server/graph/core/config.ts"() {
+    "use strict";
+    import_node_fs2 = require("node:fs");
+    import_node_path2 = require("node:path");
+    CONFIG_FILENAME = ".launchchart.json";
+  }
+});
+
 // src/server/graph/core/ast-helpers.ts
 function getTs() {
   if (!tsModule) {
@@ -114,8 +161,8 @@ function getTs() {
 }
 function parseFile(absPath) {
   const ts = getTs();
-  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path2.extname)(absPath);
+  const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path3.extname)(absPath);
   const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ext === ".ts" ? ts.ScriptKind.TS : ext === ".jsx" ? ts.ScriptKind.JSX : ts.ScriptKind.JS;
   const sourceFile = ts.createSourceFile(
     absPath,
@@ -382,8 +429,8 @@ function parseFile(absPath) {
 }
 function extractDbCalls(absPath) {
   const ts = getTs();
-  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path2.extname)(absPath);
+  const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path3.extname)(absPath);
   const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
   const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true, scriptKind);
   const calls = [];
@@ -412,8 +459,8 @@ function extractDbCalls(absPath) {
 }
 function extractAuthWrappers(absPath) {
   const ts = getTs();
-  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path2.extname)(absPath);
+  const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path3.extname)(absPath);
   const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
   const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true, scriptKind);
   const wrappers = /* @__PURE__ */ new Set();
@@ -429,12 +476,12 @@ function extractAuthWrappers(absPath) {
   visit(sourceFile);
   return wrappers;
 }
-var import_node_fs2, import_node_path2, tsModule, HTTP_METHODS, MUTATION_METHODS;
+var import_node_fs3, import_node_path3, tsModule, HTTP_METHODS, MUTATION_METHODS;
 var init_ast_helpers = __esm({
   "src/server/graph/core/ast-helpers.ts"() {
     "use strict";
-    import_node_fs2 = require("node:fs");
-    import_node_path2 = require("node:path");
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
     HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
     MUTATION_METHODS = /* @__PURE__ */ new Set([
       "create",
@@ -453,12 +500,12 @@ var init_ast_helpers = __esm({
 // src/server/graph/parsers/ui/react-nextjs.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 (!(0, import_node_fs4.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path4.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path4.extname)(entry.name))) {
       results.push(full);
     }
   }
@@ -466,33 +513,33 @@ function walk(dir, exts) {
 }
 function walkWithIgnore(dir, exts, ignoreDirs) {
   const results = [];
-  if (!(0, import_node_fs3.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+  if (!(0, import_node_fs4.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (ignoreDirs.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path3.join)(dir, entry.name), exts, ignoreDirs));
-    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
-      results.push((0, import_node_path3.join)(dir, entry.name));
+      results.push(...walkWithIgnore((0, import_node_path4.join)(dir, entry.name), exts, ignoreDirs));
+    } else if (exts.includes((0, import_node_path4.extname)(entry.name))) {
+      results.push((0, import_node_path4.join)(dir, entry.name));
     }
   }
   return results;
 }
 function toNodeId(srcDir, absPath) {
-  return (0, import_node_path3.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path4.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
   const rel = specifier.slice(2);
-  const base = (0, import_node_path3.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path3.join)(base, "index.ts"), (0, import_node_path3.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs3.existsSync)(c) && (0, import_node_fs3.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path4.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path4.join)(base, "index.ts"), (0, import_node_path4.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs4.existsSync)(c) && (0, import_node_fs4.statSync)(c).isFile()) return c;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path3.join)((0, import_node_path3.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path3.join)(base, "index.ts"), (0, import_node_path3.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs3.existsSync)(c) && (0, import_node_fs3.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path4.join)((0, import_node_path4.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path4.join)(base, "index.ts"), (0, import_node_path4.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs4.existsSync)(c) && (0, import_node_fs4.statSync)(c).isFile()) return c;
   }
   return null;
 }
@@ -513,7 +560,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path3.basename)(resolved);
+      const targetBn = (0, import_node_path4.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -540,12 +587,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_path3.basename)(absPath);
+    const bn = (0, import_node_path4.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_path3.relative)(srcDir, (0, import_node_path3.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path4.relative)(srcDir, (0, import_node_path4.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -566,34 +613,6 @@ function classifyType(id) {
   if (id.startsWith("lib/") || id.startsWith("config/")) return "lib";
   return "component";
 }
-function classifyModule(id) {
-  if (/app\/\(auth\)\//.test(id)) return "auth";
-  if (/app\/\(admin\)\//.test(id)) return "admin";
-  if (/app\/\(settings\)\//.test(id)) return "settings";
-  if (/app\/\(app\)\/\[orgSlug\]\/\(project-pages\)\//.test(id)) return "project";
-  if (/app\/\(app\)\/\[orgSlug\]\/\(org-pages\)\//.test(id)) return "org";
-  if (/app\/\(app\)\/\[orgSlug\]\//.test(id)) return "org";
-  if (id.startsWith("app/integrations/")) return "integrations";
-  if (id.startsWith("app/docs/")) return "admin";
-  if (id.startsWith("client/components/ui/")) return "shared-ui";
-  if (id.startsWith("client/components/layout/") || /client\/lib\/navigation/.test(id)) return "layout";
-  if (/client\/components\/auth\//.test(id) || /client\/lib\/auth-/.test(id) || /client\/lib\/github-oauth/.test(id) || /client\/lib\/permission-service/.test(id) || /client\/hooks\/use-permissions/.test(id)) return "auth";
-  if (/client\/components\/prd-/.test(id) || /client\/hooks\/use-admin/.test(id)) return "admin";
-  if (/client\/components\/org-/.test(id) || /client\/hooks\/use-org-/.test(id) || /client\/hooks\/use-provider-def/.test(id)) return "org";
-  if (/client\/components\/project/.test(id) || /client\/hooks\/use-project-/.test(id) || /client\/hooks\/use-pipeline/.test(id) || /client\/hooks\/use-databases/.test(id) || /client\/hooks\/use-provider-env/.test(id) || /client\/hooks\/use-role-assign/.test(id) || /client\/components\/pipeline/.test(id) || /client\/components\/deployments/.test(id)) return "project";
-  if (/client\/hooks\/use-(profile|sessions|organizations|notification)/.test(id)) return "settings";
-  if (id.startsWith("server/auth/")) return "auth";
-  if (id.startsWith("server/mcp/")) return "mcp";
-  if (id.startsWith("server/lib/")) return "server-lib";
-  if (id.startsWith("server/middleware")) return "middleware";
-  if (id.startsWith("server/services/")) return "services";
-  if (id.startsWith("server/db")) return "db";
-  if (id.startsWith("server/errors")) return "errors";
-  if (id.startsWith("server/")) return "server-lib";
-  if (id.startsWith("config/")) return "config";
-  if (id.startsWith("lib/")) return "lib";
-  return "root";
-}
 function extractRoute(id) {
   if (!id.endsWith("/page.tsx")) return null;
   let route = id.replace(/^app\//, "/").replace(/\/page\.tsx$/, "");
@@ -604,7 +623,7 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path3.basename)(absPath, (0, import_node_path3.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  return (0, import_node_path4.basename)(absPath, (0, import_node_path4.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
 function resolveTemplateLiteralRoute(template, routeToNodeId) {
   const parameterized = template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
@@ -685,105 +704,6 @@ function matchRouteToPage(route, routeToNodeId) {
   if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
   return null;
 }
-function loadApiRoutes(rootDir) {
-  const apiJsonPath = (0, import_node_path3.join)(rootDir, ".launchsecure", "graphs", "api.json");
-  if (!(0, import_node_fs3.existsSync)(apiJsonPath)) return [];
-  try {
-    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(apiJsonPath, "utf-8"));
-    const routes = [];
-    for (const n of parsed.nodes ?? []) {
-      const path3 = n.path;
-      if (!path3 || typeof path3 !== "string") continue;
-      routes.push({
-        path: path3,
-        nodeId: n.id,
-        segments: path3.split("/").filter(Boolean)
-      });
-    }
-    return routes;
-  } catch {
-    return [];
-  }
-}
-function buildApiPathMap(routes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const r of routes) {
-    if (!map.has(r.path)) map.set(r.path, r.nodeId);
-  }
-  return map;
-}
-function normalizeFetchUrl(raw) {
-  let s = raw.replace(/^`|`$/g, "");
-  const qIdx = s.indexOf("?");
-  if (qIdx >= 0) s = s.slice(0, qIdx);
-  const hIdx = s.indexOf("#");
-  if (hIdx >= 0) s = s.slice(0, hIdx);
-  let hadInterpolation = false;
-  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-    hadInterpolation = true;
-    const cleaned = expr.trim();
-    const last = cleaned.split(".").pop() ?? cleaned;
-    const name = last.replace(/[^\w]/g, "") || "param";
-    return ":" + name;
-  });
-  s = s.replace(/\/+/g, "/");
-  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
-  return { path: s || "/", hadInterpolation };
-}
-function scoreApiRouteMatch(candidate, known) {
-  if (candidate.length !== known.length) return -1;
-  let score = 0;
-  for (let i = 0; i < candidate.length; i++) {
-    const a = candidate[i];
-    const b = known[i];
-    if (a === b) {
-      score += 3;
-      continue;
-    }
-    if (a.startsWith(":") && b.startsWith(":")) {
-      score += 2;
-      continue;
-    }
-    if (a.startsWith(":") || b.startsWith(":")) {
-      score += 1;
-      continue;
-    }
-    return -1;
-  }
-  return score;
-}
-function resolveFetchCall(call, apiPathMap, apiRoutes) {
-  const raw = call.url;
-  if (/^(https?:)?\/\//i.test(raw)) {
-    return { kind: "external", normalizedUrl: raw };
-  }
-  if (call.isConcat) {
-    return { kind: "dynamic", normalizedUrl: raw };
-  }
-  const { path: path3, hadInterpolation } = normalizeFetchUrl(raw);
-  if (!path3.startsWith("/")) {
-    return { kind: "unresolved", normalizedUrl: path3 };
-  }
-  const segs = path3.split("/").filter(Boolean);
-  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
-    return { kind: "dynamic", normalizedUrl: path3 };
-  }
-  const exact = apiPathMap.get(path3);
-  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path3 };
-  let bestScore = -1;
-  let bestId = null;
-  for (const r of apiRoutes) {
-    const score = scoreApiRouteMatch(segs, r.segments);
-    if (score > bestScore) {
-      bestScore = score;
-      bestId = r.nodeId;
-    }
-  }
-  if (bestId && bestScore > 0) {
-    return { kind: "resolved", nodeId: bestId, normalizedUrl: path3 };
-  }
-  return { kind: "unresolved", normalizedUrl: path3 };
-}
 function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap, barrelMaps, routeToNodeId) {
   const edges = [];
   const flagged = [];
@@ -883,26 +803,26 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap,
   return { edges, flagged };
 }
 function detect(rootDir) {
-  return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "src", "app")) && (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.ts")) || (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.js")) || (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.mjs"));
+  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "src", "app")) && (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "next.config.ts")) || (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "next.config.js")) || (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "next.config.mjs"));
 }
 function generate(rootDir) {
-  const srcDir = (0, import_node_path3.join)(rootDir, "src");
-  const appFiles = walk((0, import_node_path3.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
-    (f) => (0, import_node_path3.basename)(f) !== "route.ts" && (0, import_node_path3.basename)(f) !== "route.tsx"
+  const srcDir = (0, import_node_path4.join)(rootDir, "src");
+  const appFiles = walk((0, import_node_path4.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
+    (f) => (0, import_node_path4.basename)(f) !== "route.ts" && (0, import_node_path4.basename)(f) !== "route.tsx"
   );
-  const clientFiles = walk((0, import_node_path3.join)(srcDir, "client"), [".tsx", ".ts"]);
-  const serverFiles = walk((0, import_node_path3.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
-    (f) => (0, import_node_path3.basename)(f) !== "route.ts" && (0, import_node_path3.basename)(f) !== "route.tsx"
+  const clientFiles = walk((0, import_node_path4.join)(srcDir, "client"), [".tsx", ".ts"]);
+  const serverFiles = walk((0, import_node_path4.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
+    (f) => (0, import_node_path4.basename)(f) !== "route.ts" && (0, import_node_path4.basename)(f) !== "route.tsx"
   );
-  const libFiles = walk((0, import_node_path3.join)(srcDir, "lib"), [".ts", ".tsx"]);
-  const configFiles = walk((0, import_node_path3.join)(srcDir, "config"), [".ts", ".tsx"]);
+  const libFiles = walk((0, import_node_path4.join)(srcDir, "lib"), [".ts", ".tsx"]);
+  const configFiles = walk((0, import_node_path4.join)(srcDir, "config"), [".ts", ".tsx"]);
   const allDiscovered = [...appFiles, ...clientFiles, ...serverFiles, ...libFiles, ...configFiles];
   const parsedByPath = /* @__PURE__ */ new Map();
   for (const absPath of allDiscovered) {
     parsedByPath.set(absPath, parseFile(absPath));
   }
   const barrelMaps = buildAllBarrelMaps(srcDir, parsedByPath);
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path3.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path4.basename)(f).startsWith("index."));
   const nodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const nodeTypeMap = /* @__PURE__ */ new Map();
@@ -913,15 +833,13 @@ function generate(rootDir) {
     const parsed = parsedByPath.get(absPath);
     const name = parsed.name || nameFromFilename(absPath);
     const route = extractRoute(id);
-    const module_ = classifyModule(id);
-    nodes.push({ id, type, name, route, module: module_, exports: parsed.exports });
+    nodes.push({ id, type, name, route, exports: parsed.exports });
     nodeIdSet.add(id);
     nodeTypeMap.set(id, type);
     if (route) routeToNodeId.set(route, id);
   }
   const allEdges = [];
   const allFlagged = [];
-  const crossRefs = [];
   for (const absPath of fileSet) {
     const sourceId = toNodeId(srcDir, absPath);
     const parsed = parsedByPath.get(absPath);
@@ -938,66 +856,21 @@ function generate(rootDir) {
     allEdges.push(...edges);
     allFlagged.push(...flagged);
   }
-  const apiRoutes = loadApiRoutes(rootDir);
-  const apiPathMap = buildApiPathMap(apiRoutes);
-  const includeExternalFetches = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
-  const fetchSeen = /* @__PURE__ */ new Set();
-  let fetchResolvedCount = 0;
-  let fetchDynamicCount = 0;
-  let fetchUnresolvedCount = 0;
-  let fetchExternalCount = 0;
+  const fetchCallEntries = [];
   for (const absPath of fileSet) {
     const sourceId = toNodeId(srcDir, absPath);
     const parsed = parsedByPath.get(absPath);
     if (parsed.fetchCalls.length === 0) continue;
-    for (const call of parsed.fetchCalls) {
-      const result = resolveFetchCall(call, apiPathMap, apiRoutes);
-      const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
-      if (result.kind === "resolved" && result.nodeId) {
-        const key = `${sourceId}\u2192${result.nodeId}\u2192calls_api`;
-        if (fetchSeen.has(key)) continue;
-        fetchSeen.add(key);
-        crossRefs.push({
-          source: sourceId,
-          target: result.nodeId,
-          type: "calls_api",
-          layer: "api"
-        });
-        fetchResolvedCount++;
-        continue;
-      }
-      if (result.kind === "dynamic") {
-        fetchDynamicCount++;
-        allFlagged.push({
-          source: sourceId,
-          target: "DYNAMIC",
-          type: "calls_api",
-          label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
-          confidence: call.isConcat ? "low" : "medium"
-        });
-        continue;
-      }
-      if (result.kind === "external") {
-        fetchExternalCount++;
-        if (!includeExternalFetches) continue;
-        allFlagged.push({
-          source: sourceId,
-          target: "EXTERNAL",
-          type: "calls_external",
-          label: `${methodTag} external fetch: ${call.url}`,
-          confidence: "high"
-        });
-        continue;
-      }
-      fetchUnresolvedCount++;
-      allFlagged.push({
-        source: sourceId,
-        target: "UNRESOLVED",
-        type: "calls_api",
-        label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
-        confidence: "medium"
-      });
-    }
+    fetchCallEntries.push({
+      nodeId: sourceId,
+      calls: parsed.fetchCalls.map((c) => ({
+        url: c.url,
+        method: c.method,
+        isTemplate: c.isTemplate,
+        isConcat: c.isConcat,
+        kind: c.kind
+      }))
+    });
   }
   const externalScanned = new Set(allDiscovered.map((f) => f.replace(/\\/g, "/")));
   const IGNORE_DIRS = /* @__PURE__ */ new Set([
@@ -1023,7 +896,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path4.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -1064,7 +937,6 @@ function generate(rootDir) {
       type: "external",
       name: parsed.name || nameFromFilename(absPath),
       route: null,
-      module: "external",
       exports: parsed.exports
     });
     nodeIdSet.add(externalId);
@@ -1114,20 +986,11 @@ function generate(rootDir) {
       layer: "ui",
       parser: "react-nextjs-ast",
       ...stats,
-      api_call_detection: {
-        includeExternalFetches,
-        includeConcatFetches: process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1",
-        apiRoutesLoaded: apiRoutes.length,
-        resolved: fetchResolvedCount,
-        dynamic: fetchDynamicCount,
-        unresolved: fetchUnresolvedCount,
-        external: fetchExternalCount
-      },
       notes: "Auto-generated via TypeScript AST \u2014 edges derived from actual imports, renders from JSX usage, navigations from router/Link calls."
     },
     nodes,
     edges: allEdges,
-    cross_refs: crossRefs,
+    cross_refs: [],
     contradictions: [],
     warnings: [],
     flagged_edges: dedupedFlagged,
@@ -1138,16 +1001,17 @@ function generate(rootDir) {
         renders: allEdges.filter((e) => e.type === "renders").length,
         imports: allEdges.filter((e) => e.type === "imports").length,
         navigates: allEdges.filter((e) => e.type === "navigates").length
-      }
+      },
+      fetch_calls: fetchCallEntries
     }
   };
 }
-var import_node_fs3, import_node_path3, RENDER_TYPES, reactNextjsParser;
+var import_node_fs4, import_node_path4, RENDER_TYPES, reactNextjsParser;
 var init_react_nextjs = __esm({
   "src/server/graph/parsers/ui/react-nextjs.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_ast_helpers();
     RENDER_TYPES = /* @__PURE__ */ new Set(["component", "ui", "layout", "context"]);
     reactNextjsParser = {
@@ -1162,9 +1026,9 @@ var init_react_nextjs = __esm({
 // src/server/graph/parsers/api/nextjs-routes.ts
 function walk2(dir) {
   const results = [];
-  if (!(0, import_node_fs4.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path4.join)(dir, entry.name);
+  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(...walk2(full));
     } else if (entry.name === "route.ts" || entry.name === "route.tsx") {
@@ -1174,7 +1038,7 @@ function walk2(dir) {
   return results;
 }
 function filePathToRoute(apiDir, absPath) {
-  let route = "/" + (0, import_node_path4.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+  let route = "/" + (0, import_node_path5.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
   route = route.replace(/\[([^\]]+)\]/g, ":$1");
   route = route.replace(/\/+/g, "/");
   if (route === "/") return "/api";
@@ -1185,10 +1049,10 @@ function camelToPascal(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
 function detect2(rootDir) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "src", "app", "api"));
+  return (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "src", "app", "api"));
 }
 function generate2(rootDir) {
-  const apiDir = (0, import_node_path4.join)(rootDir, "src", "app", "api");
+  const apiDir = (0, import_node_path5.join)(rootDir, "src", "app", "api");
   const routeFiles = walk2(apiDir);
   const nodes = [];
   const edges = [];
@@ -1206,7 +1070,7 @@ function generate2(rootDir) {
       if (HTTP_METHODS2.has(exp)) methods.push(exp);
     }
     const routePath = filePathToRoute(apiDir, absPath);
-    const relPath = (0, import_node_path4.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const relPath = (0, import_node_path5.relative)(rootDir, absPath).replace(/\\/g, "/");
     const mutations = dbCalls.filter((c) => c.isMutation);
     const reads = dbCalls.filter((c) => !c.isMutation);
     const mutates = mutations.length > 0;
@@ -1283,12 +1147,12 @@ function generate2(rootDir) {
     }
   };
 }
-var import_node_fs4, import_node_path4, HTTP_METHODS2, nextjsRoutesParser;
+var import_node_fs5, import_node_path5, HTTP_METHODS2, nextjsRoutesParser;
 var init_nextjs_routes = __esm({
   "src/server/graph/parsers/api/nextjs-routes.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");
     init_ast_helpers();
     HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
     nextjsRoutesParser = {
@@ -1391,11 +1255,11 @@ function parseEnums(content) {
   return nodes;
 }
 function detect3(rootDir) {
-  return (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "prisma", "schema.prisma"));
+  return (0, import_node_fs6.existsSync)((0, import_node_path6.join)(rootDir, "prisma", "schema.prisma"));
 }
 function generate3(rootDir) {
-  const schemaPath = (0, import_node_path5.join)(rootDir, "prisma", "schema.prisma");
-  const content = (0, import_node_fs5.readFileSync)(schemaPath, "utf-8");
+  const schemaPath = (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
+  const content = (0, import_node_fs6.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -1444,12 +1308,12 @@ function generate3(rootDir) {
     }
   };
 }
-var import_node_fs5, import_node_path5, prismaSchemaParser;
+var import_node_fs6, import_node_path6, prismaSchemaParser;
 var init_prisma_schema = __esm({
   "src/server/graph/parsers/db/prisma-schema.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");
     prismaSchemaParser = {
       id: "prisma-schema",
       layer: "db",
@@ -1459,99 +1323,1161 @@ var init_prisma_schema = __esm({
   }
 });
 
-// src/server/graph/core/graph-builder.ts
-function getParser(layer) {
-  return ALL_PARSERS.find((p) => p.layer === layer);
-}
-function generateLayer(rootDir, layer) {
-  const parser = getParser(layer);
-  if (!parser) return null;
-  if (!parser.detect(rootDir)) return null;
-  const output = parser.generate(rootDir);
-  return {
-    layer,
-    output,
-    nodeCount: output.nodes.length,
-    edgeCount: output.edges.length
-  };
-}
-function generateAll(rootDir) {
-  const layers = ["api", "db", "ui"];
-  const results = [];
-  for (const layer of layers) {
-    const result = generateLayer(rootDir, layer);
-    if (result) results.push(result);
+// src/server/graph/core/api-route-matching.ts
+function loadApiRoutesFromOutput(apiOutput) {
+  const routes = [];
+  for (const n of apiOutput.nodes) {
+    const path3 = n.path;
+    if (!path3 || typeof path3 !== "string") continue;
+    routes.push({
+      path: path3,
+      nodeId: n.id,
+      segments: path3.split("/").filter(Boolean)
+    });
   }
-  const byLayer = new Map(results.map((r) => [r.layer, r]));
-  return ["ui", "api", "db"].map((l) => byLayer.get(l)).filter((r) => !!r);
+  return routes;
 }
-var ALL_PARSERS;
-var init_graph_builder = __esm({
-  "src/server/graph/core/graph-builder.ts"() {
-    "use strict";
-    init_react_nextjs();
-    init_nextjs_routes();
-    init_prisma_schema();
-    ALL_PARSERS = [
-      reactNextjsParser,
-      nextjsRoutesParser,
-      prismaSchemaParser
-    ];
+function buildApiPathMap(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    if (!map.has(r.path)) map.set(r.path, r.nodeId);
   }
-});
-
-// src/server/graph/index.ts
-function graphsDir(rootDir) {
-  return (0, import_node_path6.join)(rootDir, GRAPHS_DIR);
-}
-function graphFilePath(rootDir, layer) {
-  return (0, import_node_path6.join)(graphsDir(rootDir), `${layer}.json`);
+  return map;
 }
-function invalidateCache(filePath) {
-  graphCache.delete(filePath);
+function normalizeFetchUrl(raw) {
+  let s = raw.replace(/^`|`$/g, "");
+  const qIdx = s.indexOf("?");
+  if (qIdx >= 0) s = s.slice(0, qIdx);
+  const hIdx = s.indexOf("#");
+  if (hIdx >= 0) s = s.slice(0, hIdx);
+  let hadInterpolation = false;
+  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    hadInterpolation = true;
+    const cleaned = expr.trim();
+    const last = cleaned.split(".").pop() ?? cleaned;
+    const name = last.replace(/[^\w]/g, "") || "param";
+    return ":" + name;
+  });
+  s = s.replace(/\/+/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return { path: s || "/", hadInterpolation };
 }
-function readGraph(rootDir, layer) {
-  const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs6.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs6.statSync)(filePath);
-  const cached = graphCache.get(filePath);
-  if (cached && cached.mtimeMs === stat.mtimeMs) {
-    return cached.graph;
+function scoreApiRouteMatch(candidate, known) {
+  if (candidate.length !== known.length) return -1;
+  let score = 0;
+  for (let i = 0; i < candidate.length; i++) {
+    const a = candidate[i];
+    const b = known[i];
+    if (a === b) {
+      score += 3;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 1;
+      continue;
+    }
+    return -1;
   }
-  const content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
-  const graph = JSON.parse(content);
-  graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
-  return graph;
+  return score;
 }
-function readAllGraphs(rootDir) {
-  const result = {};
-  for (const layer of LAYERS) {
-    const graph = readGraph(rootDir, layer);
-    if (graph) result[layer] = graph;
+function resolveFetchCall(call, apiPathMap, apiRoutes) {
+  const raw = call.url;
+  if (/^(https?:)?\/\//i.test(raw)) {
+    return { kind: "external", normalizedUrl: raw };
   }
-  return result;
-}
-function generateGraph(rootDir, layer) {
-  const dir = graphsDir(rootDir);
-  (0, import_node_fs6.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_fs6.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
-    invalidateCache(filePath);
+  if (call.isConcat) {
+    return { kind: "dynamic", normalizedUrl: raw };
   }
-  return results;
-}
-var import_node_fs6, import_node_path6, GRAPHS_DIR, LAYERS, graphCache;
-var init_graph = __esm({
-  "src/server/graph/index.ts"() {
-    "use strict";
-    import_node_fs6 = require("node:fs");
-    import_node_path6 = require("node:path");
-    init_graph_builder();
+  const { path: path3, hadInterpolation } = normalizeFetchUrl(raw);
+  if (!path3.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path3 };
+  }
+  const segs = path3.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path3 };
+  }
+  const exact = apiPathMap.get(path3);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path3 };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path3 };
+  }
+  return { kind: "unresolved", normalizedUrl: path3 };
+}
+function resolveUrlPath(urlPath, apiPathMap, apiRoutes) {
+  const { path: path3, hadInterpolation } = normalizeFetchUrl(urlPath);
+  if (!path3.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path3 };
+  }
+  const segs = path3.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path3 };
+  }
+  const exact = apiPathMap.get(path3);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path3 };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path3 };
+  }
+  return { kind: "unresolved", normalizedUrl: path3 };
+}
+var init_api_route_matching = __esm({
+  "src/server/graph/core/api-route-matching.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/graph/parsers/crosslayer/fetch-resolver.ts
+var fetchResolverParser;
+var init_fetch_resolver = __esm({
+  "src/server/graph/parsers/crosslayer/fetch-resolver.ts"() {
+    "use strict";
+    init_api_route_matching();
+    fetchResolverParser = {
+      id: "fetch-resolver",
+      layer: "crosslayer",
+      detect(_rootDir) {
+        return true;
+      },
+      generate(_rootDir, layerOutputs) {
+        const uiOutput = layerOutputs.get("ui");
+        const apiOutput = layerOutputs.get("api");
+        if (!uiOutput || !apiOutput) {
+          return { cross_refs: [], flagged_edges: [], warnings: [] };
+        }
+        const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+        const apiPathMap = buildApiPathMap(apiRoutes);
+        const fetchCallEntries = uiOutput.patterns?.fetch_calls ?? [];
+        if (fetchCallEntries.length === 0) {
+          return { cross_refs: [], flagged_edges: [], warnings: [] };
+        }
+        const includeExternal = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
+        const crossRefs = [];
+        const flaggedEdges = [];
+        const seen = /* @__PURE__ */ new Set();
+        let resolvedCount = 0;
+        let dynamicCount = 0;
+        let unresolvedCount = 0;
+        let externalCount = 0;
+        for (const entry of fetchCallEntries) {
+          for (const call of entry.calls) {
+            const result = resolveFetchCall(call, apiPathMap, apiRoutes);
+            const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
+            if (result.kind === "resolved" && result.nodeId) {
+              const key = `${entry.nodeId}\u2192${result.nodeId}\u2192calls_api`;
+              if (seen.has(key)) continue;
+              seen.add(key);
+              crossRefs.push({
+                source: entry.nodeId,
+                target: result.nodeId,
+                type: "calls_api",
+                layer: "api"
+              });
+              resolvedCount++;
+              continue;
+            }
+            if (result.kind === "dynamic") {
+              dynamicCount++;
+              flaggedEdges.push({
+                source: entry.nodeId,
+                target: "DYNAMIC",
+                type: "calls_api",
+                label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
+                confidence: call.isConcat ? "low" : "medium"
+              });
+              continue;
+            }
+            if (result.kind === "external") {
+              externalCount++;
+              if (!includeExternal) continue;
+              flaggedEdges.push({
+                source: entry.nodeId,
+                target: "EXTERNAL",
+                type: "calls_external",
+                label: `${methodTag} external fetch: ${call.url}`,
+                confidence: "high"
+              });
+              continue;
+            }
+            unresolvedCount++;
+            flaggedEdges.push({
+              source: entry.nodeId,
+              target: "UNRESOLVED",
+              type: "calls_api",
+              label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
+              confidence: "medium"
+            });
+          }
+        }
+        return {
+          cross_refs: crossRefs,
+          flagged_edges: flaggedEdges,
+          warnings: [],
+          patterns: {
+            api_call_detection: {
+              resolved: resolvedCount,
+              dynamic: dynamicCount,
+              unresolved: unresolvedCount,
+              external: externalCount
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/server/graph/parsers/crosslayer/api-annotations.ts
+function walk3(dir, exts) {
+  if (!(0, import_node_fs7.existsSync)(dir)) return [];
+  const results = [];
+  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const full = (0, import_node_path7.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk3(full, exts));
+    } else if (exts.includes((0, import_node_path7.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function toNodeId2(srcDir, absPath) {
+  return (0, import_node_path7.relative)(srcDir, absPath).replace(/\\/g, "/");
+}
+var import_node_fs7, import_node_path7, API_ANNOTATION_RE, apiAnnotationsParser;
+var init_api_annotations = __esm({
+  "src/server/graph/parsers/crosslayer/api-annotations.ts"() {
+    "use strict";
+    import_node_fs7 = require("node:fs");
+    import_node_path7 = require("node:path");
+    init_api_route_matching();
+    API_ANNOTATION_RE = /@api\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S+)/g;
+    apiAnnotationsParser = {
+      id: "api-annotations",
+      layer: "crosslayer",
+      detect(rootDir) {
+        return (0, import_node_fs7.existsSync)((0, import_node_path7.join)(rootDir, "src"));
+      },
+      generate(rootDir, layerOutputs) {
+        const apiOutput = layerOutputs.get("api");
+        if (!apiOutput) {
+          return { cross_refs: [], flagged_edges: [], warnings: [] };
+        }
+        const uiOutput = layerOutputs.get("ui");
+        const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+        const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+        const apiPathMap = buildApiPathMap(apiRoutes);
+        const srcDir = (0, import_node_path7.join)(rootDir, "src");
+        const files = walk3(srcDir, [".ts", ".tsx"]);
+        const crossRefs = [];
+        const flaggedEdges = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const absPath of files) {
+          const content = (0, import_node_fs7.readFileSync)(absPath, "utf-8");
+          const sourceId = toNodeId2(srcDir, absPath);
+          if (!uiNodeIds.has(sourceId)) continue;
+          let match;
+          API_ANNOTATION_RE.lastIndex = 0;
+          while ((match = API_ANNOTATION_RE.exec(content)) !== null) {
+            const method = match[1];
+            const urlPath = match[2];
+            const result = resolveUrlPath(urlPath, apiPathMap, apiRoutes);
+            if (result.kind === "resolved" && result.nodeId) {
+              const key = `${sourceId}|${result.nodeId}|calls_api`;
+              if (seen.has(key)) continue;
+              seen.add(key);
+              crossRefs.push({
+                source: sourceId,
+                target: result.nodeId,
+                type: "calls_api",
+                layer: "api"
+              });
+            } else {
+              flaggedEdges.push({
+                source: sourceId,
+                target: "UNRESOLVED",
+                type: "annotation_unresolved",
+                label: `@api ${method} ${urlPath} \u2014 no matching API route found`,
+                confidence: "high"
+              });
+            }
+          }
+        }
+        return {
+          cross_refs: crossRefs,
+          flagged_edges: flaggedEdges,
+          warnings: [],
+          patterns: {
+            annotations_found: crossRefs.length + flaggedEdges.length,
+            annotations_resolved: crossRefs.length,
+            annotations_unresolved: flaggedEdges.length
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/server/graph/parsers/crosslayer/url-literal-scanner.ts
+function walk4(dir, exts) {
+  if (!(0, import_node_fs8.existsSync)(dir)) return [];
+  const results = [];
+  for (const entry of (0, import_node_fs8.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()) {
+      results.push(...walk4(full, exts));
+    } else if (exts.includes((0, import_node_path8.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function toNodeId3(srcDir, absPath) {
+  return (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
+}
+var import_node_fs8, import_node_path8, URL_LITERAL_RE, urlLiteralScannerParser;
+var init_url_literal_scanner = __esm({
+  "src/server/graph/parsers/crosslayer/url-literal-scanner.ts"() {
+    "use strict";
+    import_node_fs8 = require("node:fs");
+    import_node_path8 = require("node:path");
+    init_api_route_matching();
+    URL_LITERAL_RE = /['"`](\/api\/[^'"`\s]+?)['"`]/g;
+    urlLiteralScannerParser = {
+      id: "url-literal-scanner",
+      layer: "crosslayer",
+      detect(rootDir) {
+        return (0, import_node_fs8.existsSync)((0, import_node_path8.join)(rootDir, "src"));
+      },
+      generate(rootDir, layerOutputs) {
+        const apiOutput = layerOutputs.get("api");
+        if (!apiOutput) {
+          return { cross_refs: [], flagged_edges: [], warnings: [] };
+        }
+        const uiOutput = layerOutputs.get("ui");
+        const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+        const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+        const apiPathMap = buildApiPathMap(apiRoutes);
+        const srcDir = (0, import_node_path8.join)(rootDir, "src");
+        const clientDir = (0, import_node_path8.join)(srcDir, "client");
+        const appDir = (0, import_node_path8.join)(srcDir, "app");
+        const files = [
+          ...walk4(clientDir, [".ts", ".tsx"]),
+          ...walk4(appDir, [".ts", ".tsx"])
+        ];
+        const crossRefs = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const absPath of files) {
+          const sourceId = toNodeId3(srcDir, absPath);
+          if (!uiNodeIds.has(sourceId)) continue;
+          const content = (0, import_node_fs8.readFileSync)(absPath, "utf-8");
+          let match;
+          URL_LITERAL_RE.lastIndex = 0;
+          while ((match = URL_LITERAL_RE.exec(content)) !== null) {
+            const urlPath = match[1];
+            const result = resolveUrlPath(urlPath, apiPathMap, apiRoutes);
+            if (result.kind === "resolved" && result.nodeId) {
+              const key = `${sourceId}|${result.nodeId}|references_api`;
+              if (seen.has(key)) continue;
+              seen.add(key);
+              crossRefs.push({
+                source: sourceId,
+                target: result.nodeId,
+                type: "references_api",
+                layer: "api"
+              });
+            }
+          }
+        }
+        return {
+          cross_refs: crossRefs,
+          flagged_edges: [],
+          warnings: [],
+          patterns: {
+            url_literals_resolved: crossRefs.length
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/server/graph/core/parser-registry.ts
+function registerBuiltins(registry, disabled) {
+  const builtins = [
+    reactNextjsParser,
+    nextjsRoutesParser,
+    prismaSchemaParser,
+    fetchResolverParser,
+    apiAnnotationsParser,
+    urlLiteralScannerParser
+  ];
+  for (const parser of builtins) {
+    if (disabled.has(parser.id)) continue;
+    registry.register(parser);
+  }
+}
+function loadCustomParsers(registry, config, rootDir, disabled) {
+  for (const entry of config.parsers?.custom ?? []) {
+    try {
+      const absPath = (0, import_node_path9.resolve)(rootDir, entry.path);
+      const mod = require(absPath);
+      const parser = "default" in mod ? mod.default : mod;
+      if (disabled.has(parser.id)) continue;
+      if (parser.layer !== entry.layer) {
+        process.stderr.write(
+          `[launch-chart] custom parser "${parser.id}" declares layer "${parser.layer}" but config says "${entry.layer}" \u2014 using parser's layer
+`
+        );
+      }
+      registry.register(parser);
+    } catch (err2) {
+      process.stderr.write(`[launch-chart] failed to load custom parser from ${entry.path}: ${err2}
+`);
+    }
+  }
+}
+function createRegistry(config, rootDir) {
+  const registry = new ParserRegistry();
+  const disabled = new Set(config.parsers?.disabled ?? []);
+  registerBuiltins(registry, disabled);
+  loadCustomParsers(registry, config, rootDir, disabled);
+  return registry;
+}
+var import_node_path9, ParserRegistry;
+var init_parser_registry = __esm({
+  "src/server/graph/core/parser-registry.ts"() {
+    "use strict";
+    import_node_path9 = require("node:path");
+    init_react_nextjs();
+    init_nextjs_routes();
+    init_prisma_schema();
+    init_fetch_resolver();
+    init_api_annotations();
+    init_url_literal_scanner();
+    ParserRegistry = class {
+      constructor() {
+        this.parsers = /* @__PURE__ */ new Map();
+        this.ids = /* @__PURE__ */ new Set();
+      }
+      register(parser) {
+        if (this.ids.has(parser.id)) {
+          throw new Error(`Duplicate parser id: ${parser.id}`);
+        }
+        this.ids.add(parser.id);
+        const list = this.parsers.get(parser.layer) ?? [];
+        list.push(parser);
+        this.parsers.set(parser.layer, list);
+      }
+      getParsers(layer) {
+        return this.parsers.get(layer) ?? [];
+      }
+      getCrossLayerParsers() {
+        return this.parsers.get("crosslayer") ?? [];
+      }
+      getAll() {
+        const all = [];
+        for (const list of this.parsers.values()) all.push(...list);
+        return all;
+      }
+    };
+  }
+});
+
+// src/server/graph/core/merge.ts
+function mergeGraphOutputs(outputs, layer) {
+  if (outputs.length === 0) {
+    return {
+      metadata: { generated: (/* @__PURE__ */ new Date()).toISOString(), scope: "", layer },
+      nodes: [],
+      edges: [],
+      cross_refs: [],
+      contradictions: [],
+      warnings: [],
+      flagged_edges: []
+    };
+  }
+  if (outputs.length === 1) return outputs[0];
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const seenCrossRefs = /* @__PURE__ */ new Set();
+  const mergedNodes = [];
+  const mergedEdges = [];
+  const mergedCrossRefs = [];
+  const mergedContradictions = [];
+  const mergedWarnings = [];
+  const mergedFlagged = [];
+  const parserIds = [];
+  for (const output of outputs) {
+    if (output.metadata.parser) {
+      parserIds.push(String(output.metadata.parser));
+    }
+    for (const node of output.nodes) {
+      if (seenNodes.has(node.id)) {
+        mergedWarnings.push({
+          type: "merge_conflict",
+          detail: `Node "${node.id}" produced by multiple parsers; keeping first`
+        });
+        continue;
+      }
+      seenNodes.add(node.id);
+      mergedNodes.push(node);
+    }
+    for (const edge of output.edges) {
+      const key = `${edge.source}|${edge.target}|${edge.type}`;
+      if (seenEdges.has(key)) continue;
+      seenEdges.add(key);
+      mergedEdges.push(edge);
+    }
+    for (const ref of output.cross_refs) {
+      const key = `${ref.source}|${ref.target}|${ref.type}`;
+      if (seenCrossRefs.has(key)) continue;
+      seenCrossRefs.add(key);
+      mergedCrossRefs.push(ref);
+    }
+    mergedContradictions.push(...output.contradictions);
+    mergedWarnings.push(...output.warnings);
+    mergedFlagged.push(...output.flagged_edges);
+  }
+  const metadata = {
+    ...outputs[0].metadata,
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    parsers: parserIds
+  };
+  return {
+    metadata,
+    nodes: mergedNodes,
+    edges: mergedEdges,
+    cross_refs: mergedCrossRefs,
+    contradictions: mergedContradictions,
+    warnings: mergedWarnings,
+    flagged_edges: mergedFlagged,
+    patterns: outputs[0].patterns
+  };
+}
+function dedupCrossRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ref of refs) {
+    const key = `${ref.source}|${ref.target}|${ref.type}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(ref);
+  }
+  return result;
+}
+function applyCrossLayerResults(uiOutput, results, primaryId) {
+  const allCrossRefs = [...uiOutput.cross_refs];
+  const allFlagged = [...uiOutput.flagged_edges];
+  const allWarnings = [...uiOutput.warnings];
+  const primaryResult = results.find((r) => r.parserId === primaryId);
+  const secondaryResults = results.filter((r) => r.parserId !== primaryId);
+  if (primaryResult) {
+    allCrossRefs.push(...primaryResult.output.cross_refs);
+    allFlagged.push(...primaryResult.output.flagged_edges);
+    allWarnings.push(...primaryResult.output.warnings);
+  }
+  const primarySet = new Set(
+    (primaryResult?.output.cross_refs ?? []).map((r) => `${r.source}|${r.target}|${r.type}`)
+  );
+  for (const sec of secondaryResults) {
+    for (const ref of sec.output.cross_refs) {
+      const key = `${ref.source}|${ref.target}|${ref.type}`;
+      if (primarySet.has(key)) {
+        allCrossRefs.push(ref);
+      } else {
+        allFlagged.push({
+          source: ref.source,
+          target: ref.target,
+          type: "out_of_pattern",
+          label: `API call detected by ${sec.parserId} but not by primary (${primaryId})`,
+          confidence: "medium"
+        });
+        allCrossRefs.push(ref);
+      }
+    }
+    allFlagged.push(...sec.output.flagged_edges);
+    allWarnings.push(...sec.output.warnings);
+  }
+  return {
+    ...uiOutput,
+    cross_refs: dedupCrossRefs(allCrossRefs),
+    flagged_edges: allFlagged,
+    warnings: allWarnings
+  };
+}
+var init_merge = __esm({
+  "src/server/graph/core/merge.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/graph/core/graph-builder.ts
+function readGraphFromDisk(rootDir, layer) {
+  const filePath = (0, import_node_path10.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
+  if (!(0, import_node_fs9.existsSync)(filePath)) return null;
+  try {
+    return JSON.parse((0, import_node_fs9.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function generateLayer(rootDir, layer) {
+  const config = loadConfig(rootDir);
+  const registry = createRegistry(config, rootDir);
+  const parsers = registry.getParsers(layer);
+  const outputs = [];
+  for (const parser of parsers) {
+    if (!parser.detect(rootDir)) continue;
+    outputs.push(parser.generate(rootDir));
+  }
+  if (outputs.length === 0) return null;
+  let merged = outputs.length === 1 ? outputs[0] : mergeGraphOutputs(outputs, layer);
+  if (layer === "ui") {
+    const layerOutputs = /* @__PURE__ */ new Map();
+    layerOutputs.set("ui", merged);
+    for (const otherLayer of ["api", "db"]) {
+      const existing = readGraphFromDisk(rootDir, otherLayer);
+      if (existing) layerOutputs.set(otherLayer, existing);
+    }
+    const crossParsers = registry.getCrossLayerParsers();
+    const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
+    const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
+    if (crossResults.length > 0) {
+      merged = applyCrossLayerResults(merged, crossResults, primaryId);
+    }
+  }
+  return {
+    layer,
+    output: merged,
+    nodeCount: merged.nodes.length,
+    edgeCount: merged.edges.length
+  };
+}
+function generateAll(rootDir) {
+  const config = loadConfig(rootDir);
+  const registry = createRegistry(config, rootDir);
+  const layerOrder = ["api", "db", "ui"];
+  const layerOutputs = /* @__PURE__ */ new Map();
+  const results = [];
+  for (const layer of layerOrder) {
+    const parsers = registry.getParsers(layer);
+    const outputs = [];
+    for (const parser of parsers) {
+      if (!parser.detect(rootDir)) continue;
+      outputs.push(parser.generate(rootDir));
+    }
+    if (outputs.length === 0) continue;
+    const merged = outputs.length === 1 ? outputs[0] : mergeGraphOutputs(outputs, layer);
+    layerOutputs.set(layer, merged);
+    results.push({
+      layer,
+      output: merged,
+      nodeCount: merged.nodes.length,
+      edgeCount: merged.edges.length
+    });
+  }
+  const crossParsers = registry.getCrossLayerParsers();
+  const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
+  const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
+  if (crossResults.length > 0 && layerOutputs.has("ui")) {
+    const uiOutput = layerOutputs.get("ui");
+    const merged = applyCrossLayerResults(uiOutput, crossResults, primaryId);
+    layerOutputs.set("ui", merged);
+    const uiResult = results.find((r) => r.layer === "ui");
+    if (uiResult) {
+      uiResult.output = merged;
+      uiResult.nodeCount = merged.nodes.length;
+      uiResult.edgeCount = merged.edges.length;
+    }
+  }
+  const byLayer = new Map(results.map((r) => [r.layer, r]));
+  return ["ui", "api", "db"].map((l) => byLayer.get(l)).filter((r) => !!r);
+}
+var import_node_fs9, import_node_path10;
+var init_graph_builder = __esm({
+  "src/server/graph/core/graph-builder.ts"() {
+    "use strict";
+    import_node_fs9 = require("node:fs");
+    import_node_path10 = require("node:path");
+    init_config();
+    init_parser_registry();
+    init_merge();
+  }
+});
+
+// src/server/graph/taggers/module-tagger.ts
+function matchGlob(pattern, id) {
+  const patParts = pattern.split("/");
+  const idParts = id.split("/");
+  return matchParts(patParts, 0, idParts, 0);
+}
+function matchParts(pat, pi, id, ii) {
+  while (pi < pat.length && ii < id.length) {
+    const p = pat[pi];
+    if (p === "**") {
+      for (let skip = ii; skip <= id.length; skip++) {
+        if (matchParts(pat, pi + 1, id, skip)) return true;
+      }
+      return false;
+    }
+    if (p === "*") {
+      pi++;
+      ii++;
+      continue;
+    }
+    if (p !== id[ii]) return false;
+    pi++;
+    ii++;
+  }
+  while (pi < pat.length && pat[pi] === "**") pi++;
+  return pi === pat.length && ii === id.length;
+}
+function detectConventionDirs(rootDir) {
+  const result = /* @__PURE__ */ new Map();
+  const searchDirs = [
+    rootDir,
+    (0, import_node_path11.join)(rootDir, "src"),
+    (0, import_node_path11.join)(rootDir, "app"),
+    (0, import_node_path11.join)(rootDir, "lib")
+  ];
+  for (const base of searchDirs) {
+    for (const convention of CONVENTION_DIRS) {
+      const dir = (0, import_node_path11.join)(base, convention);
+      if (!(0, import_node_fs10.existsSync)(dir)) continue;
+      try {
+        const stat = (0, import_node_fs10.statSync)(dir);
+        if (!stat.isDirectory()) continue;
+        const entries = (0, import_node_fs10.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);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function extractRouteGroups(id) {
+  const groups = [];
+  const re = /\(([^)]+)\)/g;
+  let m;
+  while ((m = re.exec(id)) !== null) {
+    groups.push(m[1]);
+  }
+  return groups;
+}
+function isRouteGroup(segment) {
+  return segment.startsWith("(") && segment.endsWith(")");
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") || segment.startsWith(":");
+}
+function isDomainDir(segment) {
+  return segment.includes(".") && !segment.endsWith(".tsx") && !segment.endsWith(".ts") && !segment.endsWith(".js") && !segment.endsWith(".jsx") && !segment.endsWith(".vue");
+}
+function isTrivialGroup(name) {
+  if (TRIVIAL_GROUPS.has(name)) return true;
+  const lower = name.toLowerCase();
+  const wrapperPatterns = [
+    /^.*-?wrapper$/,
+    // "page-wrapper", "use-page-wrapper"
+    /^.*-?layout$/,
+    // "admin-layout", "settings-layout"
+    /^use-/,
+    // "use-page-wrapper"
+    /^default$/
+  ];
+  return wrapperPatterns.some((p) => p.test(lower));
+}
+function normalizeGroupName(name) {
+  return name.replace(/-pages?$/, "").replace(/-layout$/, "").replace(/-wrapper$/, "");
+}
+function extractModuleFromPath(id) {
+  const segments = id.split("/");
+  const routeGroups = extractRouteGroups(id);
+  const moduleGroups = routeGroups.filter((g) => !isTrivialGroup(g)).map(normalizeGroupName);
+  if (moduleGroups.length > 0) {
+    return moduleGroups[moduleGroups.length - 1];
+  }
+  const meaningful = [];
+  for (const seg of segments) {
+    if (seg.includes(".")) continue;
+    if (isRouteGroup(seg)) continue;
+    if (isDynamicSegment(seg)) continue;
+    if (isDomainDir(seg)) continue;
+    if (SKIP_SEGMENTS.has(seg)) continue;
+    meaningful.push(seg);
+  }
+  if (meaningful.length > 0) {
+    return meaningful[0];
+  }
+  return "root";
+}
+var import_node_fs10, import_node_path11, CONVENTION_DIRS, SKIP_SEGMENTS, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
+var init_module_tagger = __esm({
+  "src/server/graph/taggers/module-tagger.ts"() {
+    "use strict";
+    import_node_fs10 = require("node:fs");
+    import_node_path11 = require("node:path");
+    CONVENTION_DIRS = ["features", "modules", "domains", "areas"];
+    SKIP_SEGMENTS = /* @__PURE__ */ new Set([
+      "src",
+      "app",
+      "client",
+      "server",
+      "lib",
+      "config"
+    ]);
+    TRIVIAL_GROUPS = /* @__PURE__ */ new Set([
+      "app",
+      "all",
+      "ee",
+      "home",
+      "root"
+    ]);
+    cachedRootDir = null;
+    cachedConventionDirs = /* @__PURE__ */ new Map();
+    moduleTagger = {
+      id: "module",
+      tagKey: "module",
+      trackUntagged: true,
+      layers: null,
+      // applies to all layers
+      tag(nodes, layer, rootDir) {
+        if (cachedRootDir !== rootDir) {
+          cachedConventionDirs = detectConventionDirs(rootDir);
+          cachedRootDir = rootDir;
+        }
+        let configRules = [];
+        try {
+          const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
+          const config = loadConfig2(rootDir);
+          configRules = config.taggers?.module?.rules ?? [];
+        } catch {
+        }
+        const result = /* @__PURE__ */ new Map();
+        for (const node of nodes) {
+          const id = node.id;
+          let matched = false;
+          for (const rule of configRules) {
+            if (matchGlob(rule.match, id)) {
+              result.set(id, rule.module);
+              matched = true;
+              break;
+            }
+          }
+          if (matched) continue;
+          matched = false;
+          for (const [convDir, moduleNames] of cachedConventionDirs) {
+            if (id.startsWith(convDir + "/")) {
+              const rest = id.slice(convDir.length + 1);
+              const firstSeg = rest.split("/")[0];
+              if (moduleNames.includes(firstSeg)) {
+                result.set(id, firstSeg);
+                matched = true;
+                break;
+              }
+            }
+          }
+          if (matched) continue;
+          const module2 = extractModuleFromPath(id);
+          result.set(id, module2);
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/server/graph/taggers/screen-tagger.ts
+var SCREEN_TYPES, screenTagger;
+var init_screen_tagger = __esm({
+  "src/server/graph/taggers/screen-tagger.ts"() {
+    "use strict";
+    SCREEN_TYPES = /* @__PURE__ */ new Set(["page", "layout"]);
+    screenTagger = {
+      id: "screen",
+      tagKey: "screen",
+      trackUntagged: true,
+      layers: ["ui"],
+      tag(nodes, layer) {
+        if (layer !== "ui") return /* @__PURE__ */ new Map();
+        const result = /* @__PURE__ */ new Map();
+        for (const node of nodes) {
+          if (SCREEN_TYPES.has(node.type)) {
+            result.set(node.id, "true");
+          }
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/server/graph/core/tagger-registry.ts
+function registerBuiltins2(registry, disabled, config) {
+  for (const tagger of BUILTIN_TAGGERS) {
+    if (disabled.has(tagger.id)) continue;
+    const override = config.taggers?.trackUntagged?.[tagger.id];
+    if (override !== void 0) {
+      tagger.trackUntagged = override;
+    }
+    registry.register(tagger);
+  }
+}
+function loadCustomTaggers(registry, config, rootDir, disabled) {
+  for (const entry of config.taggers?.custom ?? []) {
+    if (disabled.has(entry.id)) continue;
+    try {
+      const absPath = (0, import_node_path12.resolve)(rootDir, entry.path);
+      const mod = require(absPath);
+      const tagger = "default" in mod ? mod.default : mod;
+      const override = config.taggers?.trackUntagged?.[tagger.id];
+      if (override !== void 0) {
+        tagger.trackUntagged = override;
+      }
+      registry.register(tagger);
+    } catch (err2) {
+      process.stderr.write(`[launch-chart] failed to load custom tagger from ${entry.path}: ${err2}
+`);
+    }
+  }
+}
+function createTaggerRegistry(config, rootDir) {
+  const registry = new TaggerRegistry();
+  const disabled = new Set(config.taggers?.disabled ?? []);
+  registerBuiltins2(registry, disabled, config);
+  loadCustomTaggers(registry, config, rootDir, disabled);
+  return registry;
+}
+var import_node_path12, TaggerRegistry, BUILTIN_TAGGERS;
+var init_tagger_registry = __esm({
+  "src/server/graph/core/tagger-registry.ts"() {
+    "use strict";
+    import_node_path12 = require("node:path");
+    init_module_tagger();
+    init_screen_tagger();
+    TaggerRegistry = class {
+      constructor() {
+        this.taggers = [];
+        this.ids = /* @__PURE__ */ new Set();
+      }
+      register(tagger) {
+        if (this.ids.has(tagger.id)) {
+          throw new Error(`Duplicate tagger id: ${tagger.id}`);
+        }
+        this.ids.add(tagger.id);
+        this.taggers.push(tagger);
+      }
+      getAll() {
+        return this.taggers;
+      }
+      getForLayer(layer) {
+        return this.taggers.filter((t) => t.layers === null || t.layers.includes(layer));
+      }
+    };
+    BUILTIN_TAGGERS = [moduleTagger, screenTagger];
+  }
+});
+
+// src/server/graph/core/tag-store.ts
+function tagsFilePath(rootDir) {
+  return (0, import_node_path13.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
+}
+function readTagStore(rootDir) {
+  const filePath = tagsFilePath(rootDir);
+  if (!(0, import_node_fs11.existsSync)(filePath)) return {};
+  const stat = (0, import_node_fs11.statSync)(filePath);
+  const cached = tagCache.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs) {
+    return cached.store;
+  }
+  try {
+    const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
+    const store = JSON.parse(content);
+    tagCache.set(filePath, { mtimeMs: stat.mtimeMs, store });
+    return store;
+  } catch {
+    return {};
+  }
+}
+function writeTagStore(rootDir, store) {
+  const filePath = tagsFilePath(rootDir);
+  const dir = (0, import_node_path13.dirname)(filePath);
+  (0, import_node_fs11.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_fs11.writeFileSync)(filePath, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
+  tagCache.delete(filePath);
+}
+function setTag(rootDir, nodeId, key, value) {
+  const store = readTagStore(rootDir);
+  if (!store[nodeId]) store[nodeId] = {};
+  store[nodeId][key] = value;
+  writeTagStore(rootDir, store);
+}
+function removeTag(rootDir, nodeId, key) {
+  const store = readTagStore(rootDir);
+  if (!store[nodeId]) return;
+  delete store[nodeId][key];
+  if (Object.keys(store[nodeId]).length === 0) {
+    delete store[nodeId];
+  }
+  writeTagStore(rootDir, store);
+}
+var import_node_fs11, import_node_path13, TAGS_FILENAME, GRAPHS_DIR, tagCache;
+var init_tag_store = __esm({
+  "src/server/graph/core/tag-store.ts"() {
+    "use strict";
+    import_node_fs11 = require("node:fs");
+    import_node_path13 = require("node:path");
+    TAGS_FILENAME = "tags.json";
     GRAPHS_DIR = ".launchsecure/graphs";
+    tagCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/graph/index.ts
+function graphsDir(rootDir) {
+  return (0, import_node_path14.join)(rootDir, GRAPHS_DIR2);
+}
+function graphFilePath(rootDir, layer) {
+  return (0, import_node_path14.join)(graphsDir(rootDir), `${layer}.json`);
+}
+function tagsFilePath2(rootDir) {
+  return (0, import_node_path14.join)(graphsDir(rootDir), "tags.json");
+}
+function getMtimeMs(filePath) {
+  if (!(0, import_node_fs12.existsSync)(filePath)) return 0;
+  return (0, import_node_fs12.statSync)(filePath).mtimeMs;
+}
+function invalidateCache(filePath) {
+  graphCache.delete(filePath);
+}
+function invalidateTaggedCache(rootDir, layer) {
+  taggedCache.delete(`${rootDir}:${layer}`);
+}
+function applyTags(graph, layer, rootDir) {
+  const config = loadConfig(rootDir);
+  const registry = createTaggerRegistry(config, rootDir);
+  const manualTags = readTagStore(rootDir);
+  const taggedNodes = graph.nodes.map((n) => ({ ...n }));
+  const taggers = registry.getForLayer(layer);
+  for (const tagger of taggers) {
+    const assignments = tagger.tag(taggedNodes, layer, rootDir);
+    for (const node of taggedNodes) {
+      if (!node.tags) node.tags = {};
+      const tags = node.tags;
+      const value = assignments.get(node.id);
+      if (value !== void 0) {
+        tags[tagger.tagKey] = value;
+      } else if (tagger.trackUntagged) {
+        tags[tagger.tagKey] = "untagged";
+      }
+    }
+  }
+  for (const node of taggedNodes) {
+    const manual = manualTags[node.id];
+    if (manual) {
+      if (!node.tags) node.tags = {};
+      const tags = node.tags;
+      Object.assign(tags, manual);
+    }
+  }
+  return { ...graph, nodes: taggedNodes };
+}
+function readGraphRaw(rootDir, layer) {
+  const filePath = graphFilePath(rootDir, layer);
+  if (!(0, import_node_fs12.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs12.statSync)(filePath);
+  const cached = graphCache.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs) {
+    return cached.graph;
+  }
+  const content = (0, import_node_fs12.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_fs12.existsSync)(rawFilePath)) return null;
+  const rawMtime = getMtimeMs(rawFilePath);
+  const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
+  const cacheKey = `${rootDir}:${layer}`;
+  const cached = taggedCache.get(cacheKey);
+  if (cached && cached.rawMtimeMs === rawMtime && cached.tagsMtimeMs === tagsMtime) {
+    return cached.graph;
+  }
+  const raw = readGraphRaw(rootDir, layer);
+  if (!raw) return null;
+  const tagged = applyTags(raw, layer, rootDir);
+  taggedCache.set(cacheKey, { rawMtimeMs: rawMtime, tagsMtimeMs: tagsMtime, graph: tagged });
+  return tagged;
+}
+function readAllGraphs(rootDir) {
+  const result = {};
+  for (const layer of LAYERS) {
+    const graph = readGraph(rootDir, layer);
+    if (graph) result[layer] = graph;
+  }
+  return result;
+}
+function generateGraph(rootDir, layer) {
+  const dir = graphsDir(rootDir);
+  (0, import_node_fs12.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_fs12.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    invalidateCache(filePath);
+    invalidateTaggedCache(rootDir, result.layer);
+  }
+  return results;
+}
+var import_node_fs12, import_node_path14, GRAPHS_DIR2, LAYERS, graphCache, taggedCache;
+var init_graph = __esm({
+  "src/server/graph/index.ts"() {
+    "use strict";
+    import_node_fs12 = require("node:fs");
+    import_node_path14 = require("node:path");
+    init_graph_builder();
+    init_config();
+    init_tagger_registry();
+    init_tag_store();
+    init_tag_store();
+    GRAPHS_DIR2 = ".launchsecure/graphs";
     LAYERS = ["ui", "api", "db"];
     graphCache = /* @__PURE__ */ new Map();
+    taggedCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1561,19 +2487,22 @@ __export(chart_serve_exports, {
   runServeCli: () => runServeCli,
   startChartServer: () => startChartServer
 });
+function randomPort() {
+  return 49152 + Math.floor(Math.random() * (65535 - 49152));
+}
 function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
-    const graphsDir2 = import_node_path7.default.join(dir, ".launchsecure", "graphs");
-    if (import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "ui.json")) || import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "api.json")) || import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "db.json"))) return dir;
-    const parent = import_node_path7.default.dirname(dir);
+    const graphsDir2 = import_node_path15.default.join(dir, ".launchsecure", "graphs");
+    if (import_node_fs13.default.existsSync(import_node_path15.default.join(graphsDir2, "ui.json")) || import_node_fs13.default.existsSync(import_node_path15.default.join(graphsDir2, "api.json")) || import_node_fs13.default.existsSync(import_node_path15.default.join(graphsDir2, "db.json"))) return dir;
+    const parent = import_node_path15.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs7.default.existsSync(import_node_path7.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path7.default.dirname(dir);
+    if (import_node_fs13.default.existsSync(import_node_path15.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path15.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1625,16 +2554,16 @@ function buildMergedGraph(projectRoot) {
   };
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs7.default.existsSync(filePath) || !import_node_fs7.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path7.default.extname(filePath).toLowerCase();
+  if (!import_node_fs13.default.existsSync(filePath) || !import_node_fs13.default.statSync(filePath).isFile()) return false;
+  const ext = import_node_path15.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs7.default.createReadStream(filePath).pipe(res);
+  import_node_fs13.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path7.default.join(clientDir, "index.html");
-  if (!import_node_fs7.default.existsSync(indexPath)) {
+  const indexPath = import_node_path15.default.join(clientDir, "index.html");
+  if (!import_node_fs13.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;
@@ -1642,14 +2571,14 @@ function serveIndex(res, clientDir) {
   serveStatic(res, indexPath);
 }
 function tryListen(server, port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const onError = (err2) => {
       server.off("listening", onListening);
       reject(err2);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve(port);
+      resolve3(port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -1676,7 +2605,7 @@ async function bindWithFallback(server, startPort) {
 async function startChartServer(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const projectRoot = findProjectRoot(cwd);
-  const existing = getLiveLock();
+  const existing = getLiveLock(projectRoot);
   if (existing) {
     if (!opts.quiet) {
       process.stderr.write(
@@ -1686,7 +2615,7 @@ async function startChartServer(opts = {}) {
     }
     return { port: existing.port, url: existing.url };
   }
-  const clientDir = opts.clientDir ?? import_node_path7.default.join(__dirname, "..", "chart-client");
+  const clientDir = opts.clientDir ?? import_node_path15.default.join(__dirname, "..", "chart-client");
   const server = import_node_http.default.createServer((req, res) => {
     try {
       const url2 = new URL(req.url ?? "/", `http://${req.headers.host}`);
@@ -1724,13 +2653,154 @@ async function startChartServer(opts = {}) {
         }
         return;
       }
+      if (req.method === "GET" && url2.pathname === "/api/file-content") {
+        const relPath = url2.searchParams.get("path");
+        if (!relPath || relPath.includes("..") || import_node_path15.default.isAbsolute(relPath)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid path" }));
+          return;
+        }
+        const filePath = import_node_path15.default.join(projectRoot, relPath);
+        if (!filePath.startsWith(projectRoot) || !import_node_fs13.default.existsSync(filePath) || !import_node_fs13.default.statSync(filePath).isFile()) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "File not found" }));
+          return;
+        }
+        const ext = import_node_path15.default.extname(filePath).toLowerCase();
+        const langMap = { ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx", ".prisma": "prisma", ".json": "json", ".css": "css" };
+        const content = import_node_fs13.default.readFileSync(filePath, "utf-8");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ content, language: langMap[ext] ?? "text", path: relPath }));
+        return;
+      }
       if (req.method === "GET" && url2.pathname === "/api/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true, projectRoot }));
         return;
       }
+      if (req.method === "GET" && url2.pathname === "/api/parser-config") {
+        const config = loadConfig(projectRoot);
+        const detection = [
+          { id: "react-nextjs", layer: "ui", label: "React + Next.js", detected: reactNextjsParser.detect(projectRoot) },
+          { id: "nextjs-routes", layer: "api", label: "Next.js API Routes", detected: nextjsRoutesParser.detect(projectRoot) },
+          { id: "prisma-schema", layer: "db", label: "Prisma Schema", detected: prismaSchemaParser.detect(projectRoot) }
+        ];
+        const crosslayerParsers = [
+          { id: "fetch-resolver", label: "Fetch / api.method() calls" },
+          { id: "api-annotations", label: "@api annotations" },
+          { id: "url-literal-scanner", label: "/api/... URL literals" }
+        ];
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ config, detection, crosslayerParsers }));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/parser-config") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const newConfig = JSON.parse(body);
+            const configPath = import_node_path15.default.join(projectRoot, ".launchchart.json");
+            import_node_fs13.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) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err2) }));
+          }
+        });
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/tagger-config") {
+        const config = loadConfig(projectRoot);
+        const builtinTaggers = [
+          { id: "module", tagKey: "module", trackUntagged: config.taggers?.trackUntagged?.module ?? true },
+          { id: "screen", tagKey: "screen", trackUntagged: config.taggers?.trackUntagged?.screen ?? true }
+        ];
+        const disabled = config.taggers?.disabled ?? [];
+        const customTaggers = config.taggers?.custom ?? [];
+        const moduleRules = config.taggers?.module?.rules ?? [];
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ builtinTaggers, disabled, customTaggers, moduleRules }));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/tagger-config") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const taggerConfig = JSON.parse(body);
+            const config = loadConfig(projectRoot);
+            config.taggers = taggerConfig;
+            const configPath = import_node_path15.default.join(projectRoot, ".launchchart.json");
+            import_node_fs13.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err2) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err2) }));
+          }
+        });
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/tags") {
+        const store = readTagStore(projectRoot);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(store));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/tags") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const { nodeId, key, value } = JSON.parse(body);
+            if (!nodeId || !key || !value) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: false, error: "nodeId, key, and value are required" }));
+              return;
+            }
+            setTag(projectRoot, nodeId, key, value);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err2) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err2) }));
+          }
+        });
+        return;
+      }
+      if (req.method === "DELETE" && url2.pathname === "/api/tags") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const { nodeId, key } = JSON.parse(body);
+            if (!nodeId || !key) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: false, error: "nodeId and key are required" }));
+              return;
+            }
+            removeTag(projectRoot, nodeId, key);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err2) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err2) }));
+          }
+        });
+        return;
+      }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path7.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path15.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);
@@ -1739,7 +2809,8 @@ async function startChartServer(opts = {}) {
       res.end(JSON.stringify({ error: String(err2) }));
     }
   });
-  const port = await bindWithFallback(server, opts.port ?? DEFAULT_PORT);
+  const startPort = opts.port ?? randomPort();
+  const port = await bindWithFallback(server, startPort);
   const url = `http://localhost:${port}`;
   writeLock({
     pid: process.pid,
@@ -1747,9 +2818,9 @@ async function startChartServer(opts = {}) {
     cwd,
     url,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  }, projectRoot);
   const cleanup = () => {
-    clearLock();
+    clearLock(projectRoot);
     server.close();
   };
   process.once("SIGINT", () => {
@@ -1784,17 +2855,20 @@ function runServeCli(argv) {
     process.exit(1);
   });
 }
-var import_node_http, import_node_fs7, import_node_path7, DEFAULT_PORT, MAX_PORT_SCAN, MIME_TYPES;
+var import_node_http, import_node_fs13, import_node_path15, 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_fs7 = __toESM(require("node:fs"));
-    import_node_path7 = __toESM(require("node:path"));
+    import_node_fs13 = __toESM(require("node:fs"));
+    import_node_path15 = __toESM(require("node:path"));
     init_graph();
     init_lockfile();
-    DEFAULT_PORT = 52819;
-    MAX_PORT_SCAN = 20;
+    init_config();
+    init_react_nextjs();
+    init_nextjs_routes();
+    init_prisma_schema();
+    MAX_PORT_SCAN = 3;
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".js": "application/javascript; charset=utf-8",
@@ -1825,7 +2899,7 @@ function matchesSearch(node, query) {
 function toMinimal(nodes) {
   return nodes.map((n) => {
     const out = { id: n.id, type: n.type, name: n.name };
-    if (n.module != null) out.module = n.module;
+    if (n.tags != null) out.tags = n.tags;
     if (n.route != null) out.route = n.route;
     if (n.methods != null) out.methods = n.methods;
     return out;
@@ -1833,11 +2907,13 @@ function toMinimal(nodes) {
 }
 function toCompactNode(n) {
   const out = { i: n.id, t: n.type, n: n.name };
-  if (n.module != null) out.m = n.module;
+  const tags = n.tags;
+  if (tags?.module) out.m = tags.module;
   if (n.route != null) out.r = n.route;
   if (n.methods != null) out.mt = n.methods;
   if (n.exports != null) out.x = n.exports;
   if (n.columns != null) out.c = n.columns;
+  if (tags != null) out.tg = tags;
   for (const k of Object.keys(n)) {
     if (!COMPACT_NODE_KNOWN_KEYS.has(k) && n[k] != null) out[k] = n[k];
   }
@@ -1913,7 +2989,8 @@ function layerSummary(graph) {
   const moduleCounts = {};
   for (const n of graph.nodes) {
     typeCounts[n.type] = (typeCounts[n.type] ?? 0) + 1;
-    const mod = n.module;
+    const tags = n.tags;
+    const mod = tags?.module;
     if (mod) moduleCounts[mod] = (moduleCounts[mod] ?? 0) + 1;
   }
   const edgeTypeCounts = {};
@@ -1970,12 +3047,14 @@ function runReadGraphQueryRaw(rootDir, args) {
   const search = args.search;
   const type = args.type;
   const module_ = args.module;
+  const tagKey = args.tag_key;
+  const tagValue = args.tag_value;
   const nodeId = args.node_id;
   const hops = args.hops ?? 1;
   const layerIsDb = args.layer === "db";
   const minimal = args.minimal ?? layerIsDb;
   const includeEdges = args.include_edges;
-  const hasFilter = !!(search || type || module_ || nodeId);
+  const hasFilter = !!(search || type || module_ || nodeId || tagKey && tagValue);
   if (layer && !["ui", "api", "db"].includes(layer)) {
     return { error: `Invalid layer "${layer}". Must be one of: ui, api, db` };
   }
@@ -2031,7 +3110,9 @@ function runReadGraphQueryRaw(rootDir, args) {
   const matched = graph.nodes.filter((n) => {
     if (search && !matchesSearch(n, search)) return false;
     if (type && n.type !== type) return false;
-    if (module_ && n.module !== module_) return false;
+    const nodeTags = n.tags;
+    if (module_ && nodeTags?.module !== module_) return false;
+    if (tagKey && tagValue && nodeTags?.[tagKey] !== tagValue) return false;
     return true;
   });
   const matchedIds = new Set(matched.map((n) => n.id));
@@ -2118,9 +3199,9 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui") return (0, import_node_path8.join)(rootDir, "src", nodeId);
-  if (layer === "api") return (0, import_node_path8.join)(rootDir, nodeId);
-  if (layer === "db") return (0, import_node_path8.join)(rootDir, "prisma", "schema.prisma");
+  if (layer === "ui") return (0, import_node_path16.join)(rootDir, "src", nodeId);
+  if (layer === "api") return (0, import_node_path16.join)(rootDir, nodeId);
+  if (layer === "db") return (0, import_node_path16.join)(rootDir, "prisma", "schema.prisma");
   return null;
 }
 function handleGrepNodes(args) {
@@ -2180,11 +3261,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs8.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs14.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs14.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -2221,13 +3302,11 @@ function handleGrepNodes(args) {
     truncated
   });
 }
-function handleGetGraphUiUrl() {
-  const lock = getLiveLock();
+function handleChartServerStatus() {
+  const rootDir = process.cwd();
+  const lock = getLiveLock(rootDir);
   if (!lock) {
-    return okJson({
-      running: false,
-      hint: "No launch-chart UI server is currently running. Start one with `launch-chart serve`, or set LAUNCH_CHART_AUTOSERVE=1 in your MCP config to auto-start it alongside the MCP server."
-    });
+    return okJson({ running: false });
   }
   return okJson({
     running: true,
@@ -2238,6 +3317,146 @@ function handleGetGraphUiUrl() {
     startedAt: lock.startedAt
   });
 }
+function handleStartChartServer(args) {
+  const rootDir = process.cwd();
+  const lock = getLiveLock(rootDir);
+  if (lock) {
+    return okJson({
+      started: false,
+      reason: "already_running",
+      url: lock.url,
+      port: lock.port,
+      pid: lock.pid
+    });
+  }
+  const entryPath = process.argv[1];
+  const logDir = (0, import_node_path16.join)((0, import_node_os2.homedir)(), ".launchsecure");
+  (0, import_node_fs14.mkdirSync)(logDir, { recursive: true });
+  const logPath = (0, import_node_path16.join)(logDir, "launch-chart.log");
+  const out = (0, import_node_fs14.openSync)(logPath, "a");
+  const err2 = (0, import_node_fs14.openSync)(logPath, "a");
+  const portArgs = args.port ? ["--port", String(args.port)] : [];
+  const child = (0, import_node_child_process2.spawn)(process.execPath, [entryPath, "serve", ...portArgs], {
+    detached: true,
+    stdio: ["ignore", out, err2],
+    env: { ...process.env, LAUNCH_CHART_AUTOSERVE: "" }
+  });
+  child.unref();
+  return okJson({
+    started: true,
+    pid: child.pid,
+    logPath
+  });
+}
+function handleStopChartServer() {
+  const rootDir = process.cwd();
+  const lock = getLiveLock(rootDir);
+  if (!lock) {
+    return okJson({ stopped: false, reason: "not_running" });
+  }
+  try {
+    process.kill(lock.pid, "SIGTERM");
+    return okJson({ stopped: true, pid: lock.pid });
+  } catch (e) {
+    const code = e.code;
+    if (code === "ESRCH") {
+      clearLock(rootDir);
+      return okJson({ stopped: true, pid: lock.pid, note: "process was already gone, lock cleaned up" });
+    }
+    return okJson({ stopped: false, reason: `kill failed: ${code ?? e}` });
+  }
+}
+function handleAddTag(args) {
+  const rootDir = process.cwd();
+  const nodeId = args.node_id;
+  const key = args.key;
+  const value = args.value;
+  if (!nodeId) return err("node_id is required");
+  if (!key) return err("key is required");
+  if (!value) return err("value is required");
+  const graphs = readAllGraphs(rootDir);
+  let found = false;
+  for (const graph of Object.values(graphs)) {
+    if (graph && graph.nodes.some((n) => n.id === nodeId)) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    return err(`Node "${nodeId}" not found in any graph layer. Check the node_id.`);
+  }
+  setTag(rootDir, nodeId, key, value);
+  return okJson({ ok: true, node_id: nodeId, tag: { [key]: value } });
+}
+function handleRemoveTag(args) {
+  const rootDir = process.cwd();
+  const nodeId = args.node_id;
+  const key = args.key;
+  if (!nodeId) return err("node_id is required");
+  if (!key) return err("key is required");
+  removeTag(rootDir, nodeId, key);
+  return okJson({ ok: true, node_id: nodeId, removed_key: key });
+}
+function handleDetectProjectStack() {
+  const rootDir = process.cwd();
+  const parsers = [
+    { id: "react-nextjs", layer: "ui", detected: reactNextjsParser.detect(rootDir) },
+    { id: "nextjs-routes", layer: "api", detected: nextjsRoutesParser.detect(rootDir) },
+    { id: "prisma-schema", layer: "db", detected: prismaSchemaParser.detect(rootDir) }
+  ];
+  const config = loadConfig(rootDir);
+  let stats = { calls_api: 0, references_api: 0, out_of_pattern: 0, annotations: 0 };
+  const uiGraph = readGraph(rootDir, "ui");
+  if (uiGraph) {
+    for (const ref of uiGraph.cross_refs ?? []) {
+      if (ref.type === "calls_api") stats.calls_api++;
+      if (ref.type === "references_api") stats.references_api++;
+    }
+    for (const f of uiGraph.flagged_edges ?? []) {
+      if (f.type === "out_of_pattern") stats.out_of_pattern++;
+    }
+  }
+  const srcDir = (0, import_node_path16.join)(rootDir, "src");
+  if ((0, import_node_fs14.existsSync)(srcDir)) {
+    const scanDir = (dir) => {
+      if (!(0, import_node_fs14.existsSync)(dir)) return;
+      for (const entry of (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const full = (0, import_node_path16.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanDir(full);
+          continue;
+        }
+        if (![".ts", ".tsx"].includes((0, import_node_path16.extname)(entry.name))) continue;
+        try {
+          const content = (0, import_node_fs14.readFileSync)(full, "utf-8");
+          const matches = content.match(/@api\s+(GET|POST|PUT|DELETE|PATCH)\s+\/\S+/g);
+          if (matches) stats.annotations += matches.length;
+        } catch {
+        }
+      }
+    };
+    scanDir(srcDir);
+  }
+  let recommendedPrimary = "fetch-resolver";
+  if (stats.annotations > 0 && stats.annotations >= stats.calls_api) {
+    recommendedPrimary = "api-annotations";
+  } else if (stats.calls_api === 0 && stats.references_api > 0) {
+    recommendedPrimary = "url-literal-scanner";
+  }
+  return okJson({
+    parsers,
+    crosslayer_parsers: [
+      { id: "fetch-resolver", description: "Detects direct fetch()/api.get() calls with inline URLs" },
+      { id: "api-annotations", description: "Scans for @api METHOD /path annotations in JSDoc/comments" },
+      { id: "url-literal-scanner", description: "Finds /api/... string literals as fallback detection" }
+    ],
+    stats,
+    recommended_primary: recommendedPrimary,
+    current_config: Object.keys(config).length > 0 ? config : null,
+    config_path: ".launchchart.json"
+  });
+}
 function send(msg) {
   process.stdout.write(JSON.stringify(msg) + "\n");
 }
@@ -2281,8 +3500,28 @@ function handleMessage(msg) {
       respond(id ?? null, handleGrepNodes(args));
       return;
     }
-    if (toolName === "get_graph_ui_url") {
-      respond(id ?? null, handleGetGraphUiUrl());
+    if (toolName === "chart_server_status") {
+      respond(id ?? null, handleChartServerStatus());
+      return;
+    }
+    if (toolName === "start_chart_server") {
+      respond(id ?? null, handleStartChartServer(args));
+      return;
+    }
+    if (toolName === "stop_chart_server") {
+      respond(id ?? null, handleStopChartServer());
+      return;
+    }
+    if (toolName === "detect_project_stack") {
+      respond(id ?? null, handleDetectProjectStack());
+      return;
+    }
+    if (toolName === "add_tag") {
+      respond(id ?? null, handleAddTag(args));
+      return;
+    }
+    if (toolName === "remove_tag") {
+      respond(id ?? null, handleRemoveTag(args));
       return;
     }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
@@ -2320,14 +3559,20 @@ function startGraphMcpServer() {
   process.stderr.write(`[launchsecure-graph] MCP server started (cwd: ${process.cwd()})
 `);
 }
-var import_node_fs8, import_node_path8, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
+var import_node_fs14, import_node_path16, import_node_child_process2, import_node_os2, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
 var init_graph_mcp = __esm({
   "src/server/graph-mcp.ts"() {
     "use strict";
-    import_node_fs8 = require("node:fs");
-    import_node_path8 = require("node:path");
+    import_node_fs14 = require("node:fs");
+    import_node_path16 = require("node:path");
+    import_node_child_process2 = require("node:child_process");
+    import_node_os2 = require("node:os");
     init_graph();
     init_lockfile();
+    init_config();
+    init_react_nextjs();
+    init_nextjs_routes();
+    init_prisma_schema();
     SERVER_INFO = {
       name: "launchsecure-graph",
       version: "0.0.1"
@@ -2349,7 +3594,7 @@ var init_graph_mcp = __esm({
       },
       {
         name: "read_graph",
-        description: 'Query the structural project graph \u2014 a smart Glob replacement that locates files by type/module/name and returns structural metadata (imports, renders, routes, relations). \n\nUSE THIS FOR: "where is X", "what files are in module Y", "what pages exist under /admin", "what components does Z render", "what tables relate to User", "list all hooks in auth module". \n\nDO NOT USE FOR: finding text/code content (use Grep), reading actual source code (use Read), understanding behavior/logic/patterns (graph has no code semantics \u2014 only names and edges). \n\nQUERY PARAMS (at least one required for node data \u2014 unfiltered calls return summary only to stay in context):\n- search: substring match on node id, name, or route\n- type: filter by node type (ui layer: page, layout, component, ui, hook, context, config, util; api layer: endpoint; db layer: table, enum)\n- module: filter by module (ui layer only: auth, admin, project, org, settings, integrations, shared-ui, layout, root)\n- node_id: return this node + its neighborhood (incoming+outgoing edges within `hops`)\n- hops: neighborhood radius when node_id is set (default 1)\n- minimal: return only id/type/name/module/route per node (skip heavy fields like columns, exports)\n- include_edges: return the actual edge list. Default: TRUE for neighborhood queries (node_id), FALSE for filter queries (search/type/module). Filter responses always include `edge_count`; only pass include_edges:true when you actually need to inspect individual edges (e.g. "which components render X"). This default cuts typical filter responses in half.\n\nBATCH MODE: pass `queries` (array of query objects) to run multiple independent queries in a single call. Each query object uses the same params (layer/search/type/module/node_id/hops/minimal). Returns { batch: true, count, results: [{index, query, result}, ...] }. Use this when you need multiple graph views up-front (e.g. scoping a feature across ui+api+db layers) to save round-trips. When batch mode is used, top-level params are ignored.\n\nReturns: filtered nodes + edges between them. If no filter given, returns per-layer counts and type breakdown only.\n\nWIRE FORMAT (compact): responses that include nodes/edges use short keys and edge-by-index refs to cut payload ~40-60%. Every such response carries a `_schema` legend. Quick reference:\n  nodes[]: { i: id, t: type, n: name, m: module, r: route, mt: methods, x: exports, c: columns }\n  edges[]: { s: source_node_index, d: target_node_index, t: type, l: label }\nedges.s / edges.d are 0-based indices into THIS response\'s nodes array. If a referenced node is not in the response (boundary case), s/d may instead contain the full node id string \u2014 always check the type.\n\nBUDGET GUARDS:\n- Neighborhood queries stop expanding when the projected response exceeds budget. The response then contains `budget_exceeded: true` plus `hops_traversed < hops_requested`. When this happens, drill into a specific neighbor with another node_id call rather than retrying with larger hops \u2014 it will just truncate again.\n- Batch mode caps total response size. Once the budget is hit, later queries return `{skipped: true, reason: "batch_budget_exhausted"}` and you must re-run them individually.',
+        description: 'Query the structural project graph \u2014 a smart Glob replacement that locates files by type/module/name and returns structural metadata (imports, renders, routes, relations). \n\nUSE THIS FOR: "where is X", "what files are in module Y", "what pages exist under /admin", "what components does Z render", "what tables relate to User", "list all hooks in auth module". \n\nDO NOT USE FOR: finding text/code content (use Grep), reading actual source code (use Read), understanding behavior/logic/patterns (graph has no code semantics \u2014 only names and edges). \n\nQUERY PARAMS (at least one required for node data \u2014 unfiltered calls return summary only to stay in context):\n- search: substring match on node id, name, or route\n- type: filter by node type (ui layer: page, layout, component, ui, hook, context, config, util; api layer: endpoint; db layer: table, enum)\n- module: filter by module tag (computed from directory structure, e.g. "auth", "admin", "settings")\n- node_id: return this node + its neighborhood (incoming+outgoing edges within `hops`)\n- hops: neighborhood radius when node_id is set (default 1)\n- minimal: return only id/type/name/module/route per node (skip heavy fields like columns, exports)\n- include_edges: return the actual edge list. Default: TRUE for neighborhood queries (node_id), FALSE for filter queries (search/type/module). Filter responses always include `edge_count`; only pass include_edges:true when you actually need to inspect individual edges (e.g. "which components render X"). This default cuts typical filter responses in half.\n\nBATCH MODE: pass `queries` (array of query objects) to run multiple independent queries in a single call. Each query object uses the same params (layer/search/type/module/node_id/hops/minimal). Returns { batch: true, count, results: [{index, query, result}, ...] }. Use this when you need multiple graph views up-front (e.g. scoping a feature across ui+api+db layers) to save round-trips. When batch mode is used, top-level params are ignored.\n\nReturns: filtered nodes + edges between them. If no filter given, returns per-layer counts and type breakdown only.\n\nWIRE FORMAT (compact): responses that include nodes/edges use short keys and edge-by-index refs to cut payload ~40-60%. Every such response carries a `_schema` legend. Quick reference:\n  nodes[]: { i: id, t: type, n: name, m: module, r: route, mt: methods, x: exports, c: columns }\n  edges[]: { s: source_node_index, d: target_node_index, t: type, l: label }\nedges.s / edges.d are 0-based indices into THIS response\'s nodes array. If a referenced node is not in the response (boundary case), s/d may instead contain the full node id string \u2014 always check the type.\n\nBUDGET GUARDS:\n- Neighborhood queries stop expanding when the projected response exceeds budget. The response then contains `budget_exceeded: true` plus `hops_traversed < hops_requested`. When this happens, drill into a specific neighbor with another node_id call rather than retrying with larger hops \u2014 it will just truncate again.\n- Batch mode caps total response size. Once the budget is hit, later queries return `{skipped: true, reason: "batch_budget_exhausted"}` and you must re-run them individually.',
         inputSchema: {
           type: "object",
           properties: {
@@ -2368,7 +3613,15 @@ var init_graph_mcp = __esm({
             },
             module: {
               type: "string",
-              description: 'UI layer only \u2014 filter by module (e.g. "auth", "admin", "project", "org").'
+              description: 'Filter by module tag (e.g. "auth", "admin", "settings"). Works across all layers.'
+            },
+            tag_key: {
+              type: "string",
+              description: "Filter by arbitrary tag key. Must be used with tag_value."
+            },
+            tag_value: {
+              type: "string",
+              description: "Filter by tag value for the given tag_key."
             },
             node_id: {
               type: "string",
@@ -2455,12 +3708,83 @@ Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line
         }
       },
       {
-        name: "get_graph_ui_url",
-        description: 'Return the URL of a running launch-chart UI server if one exists. The UI is a visual, interactive view of the merged UI+API+DB project graph served by `launch-chart serve` (or auto-started via LAUNCH_CHART_AUTOSERVE=1). \n\nReturns: { running: boolean, url?: string, port?: number, pid?: number, startedAt?: string, cwd?: string }. If running is false, no server is currently live \u2014 suggest the user run `launch-chart serve` to start one. \n\nUse this when the user asks "open the graph", "show me the project graph UI", "where\'s the chart", etc.',
+        name: "chart_server_status",
+        description: `Check whether the launch-chart UI server is running. Returns: { running: boolean, url?: string, port?: number, pid?: number, startedAt?: string, cwd?: string }. 
+
+Use this when the user asks "is the chart running", "show me the project graph UI", "where's the chart", etc.`,
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "start_chart_server",
+        description: 'Start the launch-chart UI server as a detached background process. The server serves the interactive project graph visualization at http://localhost:<port>. If the server is already running, returns the existing URL without spawning a duplicate. \n\nUse this when the user asks to "start the chart", "fire up charts", "open the graph UI", etc.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            port: {
+              type: "number",
+              description: "Port to bind the server to. Defaults to 52819 with automatic fallback if in use."
+            }
+          }
+        }
+      },
+      {
+        name: "stop_chart_server",
+        description: 'Stop the running launch-chart UI server. Sends SIGTERM to the server process and cleans up the lock file. If no server is running, returns a no-op response. \n\nUse this when the user asks to "stop the chart", "cool down charts", "kill the graph server", etc.',
         inputSchema: {
           type: "object",
           properties: {}
         }
+      },
+      {
+        name: "detect_project_stack",
+        description: "Detect project frameworks, available parsers, and recommend parser configuration. Scans the project to identify the tech stack (Next.js, Prisma, React, etc.), reports which built-in parsers are applicable, and provides cross-layer detection stats (fetch calls, @api annotations, URL literals). Returns a recommended primary parser and current .launchchart.json config if present. \n\nUse this when setting up launch-chart for a new project or reviewing parser configuration.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "add_tag",
+        description: 'Tag a graph node with a key-value pair. Tags persist in .launchsecure/graphs/tags.json and survive graph regeneration. Use for annotating nodes with arbitrary metadata (e.g. "refactor_later", "owner", "priority"). Manual tags override computed tags (like module and screen) for the same key.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            node_id: {
+              type: "string",
+              description: 'The node id to tag (e.g. "app/(auth)/login/page.tsx").'
+            },
+            key: {
+              type: "string",
+              description: 'Tag key (e.g. "module", "owner", "refactor_later").'
+            },
+            value: {
+              type: "string",
+              description: 'Tag value (e.g. "auth", "alice", "true").'
+            }
+          },
+          required: ["node_id", "key", "value"]
+        }
+      },
+      {
+        name: "remove_tag",
+        description: "Remove a manual tag from a graph node. Only removes tags from tags.json \u2014 computed tags (module, screen) cannot be removed (they are re-derived at read time).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            node_id: {
+              type: "string",
+              description: "The node id to remove the tag from."
+            },
+            key: {
+              type: "string",
+              description: "Tag key to remove."
+            }
+          },
+          required: ["node_id", "key"]
+        }
       }
     ];
     COMPACT_SCHEMA = {
@@ -2468,11 +3792,12 @@ Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line
         i: "id",
         t: "type",
         n: "name",
-        m: "module",
+        m: "module (from tags)",
         r: "route",
         mt: "methods",
         x: "exports",
-        c: "columns"
+        c: "columns",
+        tg: "tags"
       },
       edges: {
         s: "source_node_index",
@@ -2490,7 +3815,8 @@ Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line
       "route",
       "methods",
       "exports",
-      "columns"
+      "columns",
+      "tags"
     ]);
     EST_CHARS_PER_NODE_FULL = {
       ui: 300,
@@ -2513,11 +3839,11 @@ Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line
 });
 
 // src/server/graph-mcp-entry.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs9 = require("node:fs");
-var import_node_path9 = __toESM(require("node:path"));
-var import_node_os2 = require("node:os");
-var import_node_fs10 = require("node:fs");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs15 = require("node:fs");
+var import_node_path17 = __toESM(require("node:path"));
+var import_node_os3 = require("node:os");
+var import_node_fs16 = require("node:fs");
 init_lockfile();
 function logStderr(msg) {
   process.stderr.write(`[launch-chart] ${msg}
@@ -2531,13 +3857,13 @@ function maybeAutoServe() {
     return;
   }
   try {
-    const logDir = import_node_path9.default.join((0, import_node_os2.homedir)(), ".launchsecure");
-    (0, import_node_fs10.mkdirSync)(logDir, { recursive: true });
-    const logPath = import_node_path9.default.join(logDir, "launch-chart.log");
-    const out = (0, import_node_fs9.openSync)(logPath, "a");
-    const err2 = (0, import_node_fs9.openSync)(logPath, "a");
+    const logDir = import_node_path17.default.join((0, import_node_os3.homedir)(), ".launchsecure");
+    (0, import_node_fs16.mkdirSync)(logDir, { recursive: true });
+    const logPath = import_node_path17.default.join(logDir, "launch-chart.log");
+    const out = (0, import_node_fs15.openSync)(logPath, "a");
+    const err2 = (0, import_node_fs15.openSync)(logPath, "a");
     const entryPath = process.argv[1];
-    const child = (0, import_node_child_process2.spawn)(process.execPath, [entryPath, "serve"], {
+    const child = (0, import_node_child_process3.spawn)(process.execPath, [entryPath, "serve"], {
       detached: true,
       stdio: ["ignore", out, err2],
       env: { ...process.env, LAUNCH_CHART_AUTOSERVE: "" }