@launchsecure/launch-kit 0.0.45 → 0.0.46

package/dist/server/cli.js

@@ -22157,20 +22157,20 @@ __export(config_exports, {
   loadConfig: () => loadConfig
 });
 function loadConfig(rootDir) {
-  const configPath = (0, import_node_path5.join)(rootDir, LAUNCHCHART_CONFIG_FILE);
-  if (!(0, import_node_fs5.existsSync)(configPath)) return {};
+  const configPath = (0, import_node_path6.join)(rootDir, LAUNCHCHART_CONFIG_FILE);
+  if (!(0, import_node_fs6.existsSync)(configPath)) return {};
   try {
-    return JSON.parse((0, import_node_fs5.readFileSync)(configPath, "utf-8"));
+    return JSON.parse((0, import_node_fs6.readFileSync)(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
-var import_node_fs5, import_node_path5;
+var import_node_fs6, import_node_path6;
 var init_config = __esm({
   "src/server/graph/core/config.ts"() {
     "use strict";
-    import_node_fs5 = require("node:fs");
-    import_node_path5 = require("node:path");
+    import_node_fs6 = require("node:fs");
+    import_node_path6 = require("node:path");
     init_launch_kit_paths();
   }
 });
@@ -22207,18 +22207,18 @@ function detectConventionDirs(rootDir, extraConventionDirs = []) {
   const conventionDirs = [...CONVENTION_DIRS_BUILTIN, ...extraConventionDirs];
   const searchDirs = [
     rootDir,
-    (0, import_node_path6.join)(rootDir, "src"),
-    (0, import_node_path6.join)(rootDir, "app"),
-    (0, import_node_path6.join)(rootDir, "lib")
+    (0, import_node_path7.join)(rootDir, "src"),
+    (0, import_node_path7.join)(rootDir, "app"),
+    (0, import_node_path7.join)(rootDir, "lib")
   ];
   for (const base of searchDirs) {
     for (const convention of conventionDirs) {
-      const dir = (0, import_node_path6.join)(base, convention);
-      if (!(0, import_node_fs6.existsSync)(dir)) continue;
+      const dir = (0, import_node_path7.join)(base, convention);
+      if (!(0, import_node_fs7.existsSync)(dir)) continue;
       try {
-        const stat = (0, import_node_fs6.statSync)(dir);
+        const stat = (0, import_node_fs7.statSync)(dir);
         if (!stat.isDirectory()) continue;
-        const entries = (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+        const entries = (0, import_node_fs7.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);
@@ -22294,12 +22294,12 @@ function extractModuleFromPath(id, extraTrivial, extraSkipSegments, extraGeneric
   }
   return "root";
 }
-var import_node_fs6, import_node_path6, CONVENTION_DIRS_BUILTIN, GENERIC_ROLE_NAMES_BUILTIN, SKIP_SEGMENTS_BUILTIN, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
+var import_node_fs7, import_node_path7, CONVENTION_DIRS_BUILTIN, GENERIC_ROLE_NAMES_BUILTIN, SKIP_SEGMENTS_BUILTIN, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
 var init_module_tagger = __esm({
   "src/server/graph/taggers/module-tagger.ts"() {
     "use strict";
-    import_node_fs6 = require("node:fs");
-    import_node_path6 = require("node:path");
+    import_node_fs7 = require("node:fs");
+    import_node_path7 = require("node:path");
     CONVENTION_DIRS_BUILTIN = ["features", "modules", "domains", "areas"];
     GENERIC_ROLE_NAMES_BUILTIN = /* @__PURE__ */ new Set([
       // JS/TS
@@ -22514,7 +22514,7 @@ 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_path7.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path8.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const tagger = "default" in mod ? mod.default : mod;
       const override = config.taggers?.trackUntagged?.[tagger.id];
@@ -22535,11 +22535,11 @@ function createTaggerRegistry(config, rootDir) {
   loadCustomTaggers(registry, config, rootDir, disabled);
   return registry;
 }
-var import_node_path7, TaggerRegistry, BUILTIN_TAGGERS;
+var import_node_path8, TaggerRegistry, BUILTIN_TAGGERS;
 var init_tagger_registry = __esm({
   "src/server/graph/core/tagger-registry.ts"() {
     "use strict";
-    import_node_path7 = require("node:path");
+    import_node_path8 = require("node:path");
     init_module_tagger();
     init_screen_tagger();
     TaggerRegistry = class {
@@ -22567,42 +22567,42 @@ var init_tagger_registry = __esm({
 
 // src/server/graph/core/atomic-write.ts
 function atomicWriteFileSync(filePath, content, encoding = "utf-8") {
-  (0, import_node_fs7.mkdirSync)((0, import_node_path8.dirname)(filePath), { recursive: true });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   try {
-    (0, import_node_fs7.writeFileSync)(tmp, content, typeof content === "string" ? encoding : void 0);
-    (0, import_node_fs7.renameSync)(tmp, filePath);
+    (0, import_node_fs8.writeFileSync)(tmp, content, typeof content === "string" ? encoding : void 0);
+    (0, import_node_fs8.renameSync)(tmp, filePath);
   } catch (e) {
     try {
-      (0, import_node_fs7.unlinkSync)(tmp);
+      (0, import_node_fs8.unlinkSync)(tmp);
     } catch {
     }
     throw e;
   }
 }
-var import_node_fs7, import_node_path8;
+var import_node_fs8, import_node_path9;
 var init_atomic_write = __esm({
   "src/server/graph/core/atomic-write.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_node_path8 = require("node:path");
+    import_node_fs8 = require("node:fs");
+    import_node_path9 = require("node:path");
   }
 });
 
 // src/server/graph/core/tag-store.ts
 function tagsFilePath(rootDir) {
-  return (0, import_node_path9.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
+  return (0, import_node_path10.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
 }
 function readTagStore(rootDir) {
   const filePath = tagsFilePath(rootDir);
-  if (!(0, import_node_fs8.existsSync)(filePath)) return {};
-  const stat = (0, import_node_fs8.statSync)(filePath);
+  if (!(0, import_node_fs9.existsSync)(filePath)) return {};
+  const stat = (0, import_node_fs9.statSync)(filePath);
   const cached = tagCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.store;
   }
   try {
-    const content = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs9.readFileSync)(filePath, "utf-8");
     const store = JSON.parse(content);
     tagCache.set(filePath, { mtimeMs: stat.mtimeMs, store });
     return store;
@@ -22612,8 +22612,8 @@ function readTagStore(rootDir) {
 }
 function writeTagStore(rootDir, store) {
   const filePath = tagsFilePath(rootDir);
-  const dir = (0, import_node_path9.dirname)(filePath);
-  (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path10.dirname)(filePath);
+  (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
   const cleaned = {};
   for (const [nodeId, tags] of Object.entries(store)) {
     if (Object.keys(tags).length > 0) {
@@ -22638,12 +22638,12 @@ function removeTag(rootDir, nodeId, key) {
   }
   writeTagStore(rootDir, store);
 }
-var import_node_fs8, import_node_path9, TAGS_FILENAME, GRAPHS_DIR, tagCache;
+var import_node_fs9, import_node_path10, TAGS_FILENAME, GRAPHS_DIR, tagCache;
 var init_tag_store = __esm({
   "src/server/graph/core/tag-store.ts"() {
     "use strict";
-    import_node_fs8 = require("node:fs");
-    import_node_path9 = require("node:path");
+    import_node_fs9 = require("node:fs");
+    import_node_path10 = require("node:path");
     init_atomic_write();
     TAGS_FILENAME = "tags.json";
     GRAPHS_DIR = ".launchsecure/graphs";
@@ -22653,10 +22653,10 @@ var init_tag_store = __esm({
 
 // src/server/graph/core/parse-worker-host.ts
 function resolveWorkerPath() {
-  const sibling = (0, import_node_path10.join)(__dirname, "parse-worker-entry.js");
-  if ((0, import_node_fs9.existsSync)(sibling)) return sibling;
-  const srcSibling = (0, import_node_path10.join)(__dirname, "..", "..", "parse-worker-entry.ts");
-  if ((0, import_node_fs9.existsSync)(srcSibling)) return srcSibling;
+  const sibling = (0, import_node_path11.join)(__dirname, "parse-worker-entry.js");
+  if ((0, import_node_fs10.existsSync)(sibling)) return sibling;
+  const srcSibling = (0, import_node_path11.join)(__dirname, "..", "..", "parse-worker-entry.ts");
+  if ((0, import_node_fs10.existsSync)(srcSibling)) return srcSibling;
   throw new Error(
     `parse-worker-entry not found. Build the chart server first (pnpm --filter @launchsecure/launch-kit build:server). Looked at: ${sibling} and ${srcSibling}`
   );
@@ -22698,12 +22698,12 @@ function runParseInWorker(req) {
     worker.postMessage(req);
   });
 }
-var import_node_fs9, import_node_path10, import_node_worker_threads;
+var import_node_fs10, import_node_path11, import_node_worker_threads;
 var init_parse_worker_host = __esm({
   "src/server/graph/core/parse-worker-host.ts"() {
     "use strict";
-    import_node_fs9 = require("node:fs");
-    import_node_path10 = require("node:path");
+    import_node_fs10 = require("node:fs");
+    import_node_path11 = require("node:path");
     import_node_worker_threads = require("node:worker_threads");
   }
 });
@@ -22761,16 +22761,16 @@ function buildEffectsIndex(layerOutputs) {
   return idx;
 }
 function writeEffectsIndex(rootDir, idx) {
-  const path13 = (0, import_node_path11.join)(rootDir, LAUNCHSECURE_DIR, "graphs", "effects-index.json");
+  const path13 = (0, import_node_path12.join)(rootDir, LAUNCHSECURE_DIR, "graphs", "effects-index.json");
   atomicWriteFileSync(path13, JSON.stringify(idx, null, 2) + "\n");
   return path13;
 }
-var import_node_path11;
+var import_node_path12;
 var init_effects_index = __esm({
   "src/server/graph/core/effects-index.ts"() {
     "use strict";
     init_atomic_write();
-    import_node_path11 = require("node:path");
+    import_node_path12 = require("node:path");
     init_launch_kit_paths();
   }
 });
@@ -22870,13 +22870,13 @@ var init_nextjs_prisma = __esm({
 
 // src/server/graph/core/context/overlay.ts
 function overlayPath(rootDir) {
-  return (0, import_node_path12.join)(rootDir, OVERLAY_FILE);
+  return (0, import_node_path13.join)(rootDir, OVERLAY_FILE);
 }
 function loadOverlay(rootDir) {
   const path13 = overlayPath(rootDir);
-  if (!(0, import_node_fs10.existsSync)(path13)) return null;
+  if (!(0, import_node_fs11.existsSync)(path13)) return null;
   try {
-    return JSON.parse((0, import_node_fs10.readFileSync)(path13, "utf-8"));
+    return JSON.parse((0, import_node_fs11.readFileSync)(path13, "utf-8"));
   } catch (e) {
     process.stderr.write(`[launch-chart] failed to parse ${OVERLAY_FILE}: ${e.message}
 `);
@@ -22892,18 +22892,18 @@ function applyOverlayRejections(edges, rootDir) {
   );
   return edges.filter((e) => !rejectKeys.has(`${e.source}|${e.type}|${e.target}`));
 }
-var import_node_fs10, import_node_path12, OVERLAY_FILE, overlayProvider;
+var import_node_fs11, import_node_path13, OVERLAY_FILE, overlayProvider;
 var init_overlay = __esm({
   "src/server/graph/core/context/overlay.ts"() {
     "use strict";
-    import_node_fs10 = require("node:fs");
-    import_node_path12 = require("node:path");
+    import_node_fs11 = require("node:fs");
+    import_node_path13 = require("node:path");
     init_types();
     OVERLAY_FILE = ".launchchart.context.json";
     overlayProvider = {
       id: "overlay",
       detect(_layerOutputs, rootDir) {
-        return (0, import_node_fs10.existsSync)(overlayPath(rootDir));
+        return (0, import_node_fs11.existsSync)(overlayPath(rootDir));
       },
       derive(_layerOutputs, rootDir) {
         const overlay = loadOverlay(rootDir);
@@ -22952,7 +22952,7 @@ function registerBuiltins2(registry, disabled) {
 function loadCustomProviders(registry, config, rootDir, disabled) {
   for (const entry of config.context?.providers ?? []) {
     try {
-      const absPath = (0, import_node_path13.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path14.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const provider = "default" in mod ? mod.default : mod;
       if (disabled.has(provider.id)) continue;
@@ -22970,11 +22970,11 @@ function createContextProviderRegistry(config, rootDir) {
   loadCustomProviders(registry, config, rootDir, disabled);
   return registry;
 }
-var import_node_path13, ContextProviderRegistry;
+var import_node_path14, ContextProviderRegistry;
 var init_registry = __esm({
   "src/server/graph/core/context/registry.ts"() {
     "use strict";
-    import_node_path13 = require("node:path");
+    import_node_path14 = require("node:path");
     init_nextjs_prisma();
     init_overlay();
     ContextProviderRegistry = class {
@@ -23079,16 +23079,16 @@ function buildContextMap(layerOutputs, rootDir) {
   };
 }
 function writeContextMap(rootDir, output) {
-  const path13 = (0, import_node_path14.join)(rootDir, LAUNCHSECURE_DIR, "graphs", "context.json");
+  const path13 = (0, import_node_path15.join)(rootDir, LAUNCHSECURE_DIR, "graphs", "context.json");
   atomicWriteFileSync(path13, JSON.stringify(output, null, 2) + "\n");
   return path13;
 }
-var import_node_path14;
+var import_node_path15;
 var init_context_map = __esm({
   "src/server/graph/core/context-map.ts"() {
     "use strict";
     init_atomic_write();
-    import_node_path14 = require("node:path");
+    import_node_path15 = require("node:path");
     init_launch_kit_paths();
     init_config();
     init_registry();
@@ -23112,12 +23112,12 @@ function getFreshnessTracker(rootDir) {
   }
   return t;
 }
-var import_node_fs11, import_node_path15, SCHEMA_VERSION, MAX_PATCHED_FILES_TRACKED, DRIFTING_PATCH_THRESHOLD, HARD_ESCALATION_PATTERNS, FreshnessTracker, trackers;
+var import_node_fs12, import_node_path16, SCHEMA_VERSION, MAX_PATCHED_FILES_TRACKED, DRIFTING_PATCH_THRESHOLD, HARD_ESCALATION_PATTERNS, FreshnessTracker, trackers;
 var init_freshness = __esm({
   "src/server/graph/core/freshness.ts"() {
     "use strict";
-    import_node_fs11 = require("node:fs");
-    import_node_path15 = require("node:path");
+    import_node_fs12 = require("node:fs");
+    import_node_path16 = require("node:path");
     init_launch_kit_paths();
     init_atomic_write();
     SCHEMA_VERSION = 1;
@@ -23134,7 +23134,7 @@ var init_freshness = __esm({
     FreshnessTracker = class {
       constructor(rootDir) {
         this.dirty = false;
-        this.filePath = (0, import_node_path15.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".freshness.json");
+        this.filePath = (0, import_node_path16.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".freshness.json");
         this.snapshot = this.load() ?? {
           state: "fresh",
           lastFullRegenAt: null,
@@ -23221,9 +23221,9 @@ var init_freshness = __esm({
         }
       }
       load() {
-        if (!(0, import_node_fs11.existsSync)(this.filePath)) return null;
+        if (!(0, import_node_fs12.existsSync)(this.filePath)) return null;
         try {
-          const parsed = JSON.parse((0, import_node_fs11.readFileSync)(this.filePath, "utf-8"));
+          const parsed = JSON.parse((0, import_node_fs12.readFileSync)(this.filePath, "utf-8"));
           if (parsed.schemaVersion !== SCHEMA_VERSION) return null;
           return {
             state: parsed.state,
@@ -23245,22 +23245,22 @@ var init_freshness = __esm({
 
 // src/server/graph/index.ts
 function getAvailableLayers(rootDir) {
-  const dir = (0, import_node_path16.join)(rootDir, GRAPHS_DIR2);
-  if (!(0, import_node_fs12.existsSync)(dir)) return [];
-  return (0, import_node_fs12.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".") && !NON_LAYER_GRAPH_FILES.has(f)).map((f) => f.replace(".json", ""));
+  const dir = (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
+  if (!(0, import_node_fs13.existsSync)(dir)) return [];
+  return (0, import_node_fs13.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".") && !NON_LAYER_GRAPH_FILES.has(f)).map((f) => f.replace(".json", ""));
 }
 function graphsDir(rootDir) {
-  return (0, import_node_path16.join)(rootDir, GRAPHS_DIR2);
+  return (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path16.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path17.join)(graphsDir(rootDir), `${layer}.json`);
 }
 function tagsFilePath2(rootDir) {
-  return (0, import_node_path16.join)(graphsDir(rootDir), "tags.json");
+  return (0, import_node_path17.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;
+  if (!(0, import_node_fs13.existsSync)(filePath)) return 0;
+  return (0, import_node_fs13.statSync)(filePath).mtimeMs;
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
@@ -23299,20 +23299,20 @@ function applyTags(graph, layer, rootDir) {
 }
 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);
+  if (!(0, import_node_fs13.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs13.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 content = (0, import_node_fs13.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;
+  if (!(0, import_node_fs13.existsSync)(rawFilePath)) return null;
   const rawMtime = getMtimeMs(rawFilePath);
   const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
   const cacheKey = `${rootDir}:${layer}`;
@@ -23336,7 +23336,7 @@ function readAllGraphs(rootDir) {
 }
 async function generateGraph(rootDir, layer) {
   const dir = graphsDir(rootDir);
-  (0, import_node_fs12.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
   const { results, failedFiles } = await runParseInWorker({ rootDir, layer });
   for (const result of results) {
     const filePath = graphFilePath(rootDir, result.layer);
@@ -23347,13 +23347,13 @@ async function generateGraph(rootDir, layer) {
   if (!layer) {
     const producedLayers = new Set(results.map((r) => r.layer));
     try {
-      for (const f of (0, import_node_fs12.readdirSync)(dir)) {
+      for (const f of (0, import_node_fs13.readdirSync)(dir)) {
         if (!f.endsWith(".json") || f === "tags.json" || f === "effects-index.json" || f === "context.json") continue;
         const layerName = f.replace(/\.json$/, "");
         if (producedLayers.has(layerName)) continue;
-        const orphan = (0, import_node_path16.join)(dir, f);
+        const orphan = (0, import_node_path17.join)(dir, f);
         try {
-          (0, import_node_fs12.unlinkSync)(orphan);
+          (0, import_node_fs13.unlinkSync)(orphan);
           invalidateCache(orphan);
           invalidateTaggedCache(rootDir, layerName);
           process.stderr.write(`[launch-chart] removed orphan layer file: ${f} (no parser produced ${layerName} this run)
@@ -23367,7 +23367,7 @@ async function generateGraph(rootDir, layer) {
   const allLayers = {};
   for (const r of results) allLayers[r.layer] = r.output;
   if (layer) {
-    for (const f of (0, import_node_fs12.readdirSync)(dir)) {
+    for (const f of (0, import_node_fs13.readdirSync)(dir)) {
       if (!f.endsWith(".json") || f.startsWith(".") || f === "tags.json" || f === "effects-index.json" || f === "context.json") continue;
       const layerName = f.replace(/\.json$/, "");
       if (allLayers[layerName]) continue;
@@ -23405,20 +23405,20 @@ async function generateGraph(rootDir, layer) {
   return results;
 }
 function readEffectsIndex(rootDir) {
-  const path13 = (0, import_node_path16.join)(rootDir, GRAPHS_DIR2, "effects-index.json");
-  if (!(0, import_node_fs12.existsSync)(path13)) return null;
+  const path13 = (0, import_node_path17.join)(rootDir, GRAPHS_DIR2, "effects-index.json");
+  if (!(0, import_node_fs13.existsSync)(path13)) return null;
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)(path13, "utf-8"));
+    return JSON.parse((0, import_node_fs13.readFileSync)(path13, "utf-8"));
   } catch {
     return null;
   }
 }
-var import_node_fs12, import_node_path16, GRAPHS_DIR2, NON_LAYER_GRAPH_FILES, graphCache, taggedCache;
+var import_node_fs13, import_node_path17, GRAPHS_DIR2, NON_LAYER_GRAPH_FILES, graphCache, taggedCache;
 var init_graph = __esm({
   "src/server/graph/index.ts"() {
     "use strict";
-    import_node_fs12 = require("node:fs");
-    import_node_path16 = require("node:path");
+    import_node_fs13 = require("node:fs");
+    import_node_path17 = require("node:path");
     init_config();
     init_tagger_registry();
     init_tag_store();
@@ -23502,8 +23502,8 @@ function getQuery(name) {
   ensureInit();
   const cached = queryCache.get(name);
   if (cached) return cached;
-  const scmPath = (0, import_node_path22.join)(queriesDir, `${name}.scm`);
-  const scm = (0, import_node_fs17.readFileSync)(scmPath, "utf-8");
+  const scmPath = (0, import_node_path23.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs18.readFileSync)(scmPath, "utf-8");
   const query = tsxLanguage.query(scm);
   queryCache.set(name, query);
   return query;
@@ -23523,13 +23523,13 @@ function parseSource(absPath) {
   ensureInit();
   let content;
   try {
-    const stat = (0, import_node_fs17.statSync)(absPath);
+    const stat = (0, import_node_fs18.statSync)(absPath);
     if (stat.size > MAX_PARSEABLE_BYTES) {
       process.stderr.write(`[lc-extractor] skipping ${absPath}: ${stat.size} bytes exceeds max ${MAX_PARSEABLE_BYTES}
 `);
       return null;
     }
-    content = (0, import_node_fs17.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs18.readFileSync)(absPath, "utf-8");
   } catch (e) {
     process.stderr.write(`[lc-extractor] read failed for ${absPath}: ${e instanceof Error ? e.message : String(e)}
 `);
@@ -24563,18 +24563,18 @@ function collectUiLabels(root) {
   visit(root);
   return out;
 }
-var import_node_fs17, import_node_path22, tsxLanguage, parserInstance, TreeSitterCtor, initPromise, initialized, queriesDir, queryCache, MAX_PARSEABLE_BYTES, MAX_CONSECUTIVE_PARSE_FAILURES, consecutiveParseFailures, ParseCascadeError, PRISMA_MUTATION_METHODS_BUILTIN, SUPABASE_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods, INLINE_AUTH_IMPORTS, EXEMPT_NAME_PATTERNS, PROTECT_NAME_PATTERNS, TRUST_AS_PROTECT_KEYS, TIMER_FNS, DOM_METHOD_NAMES, CLASSLIST_METHODS, STORAGE_OBJECTS, HISTORY_METHODS, LOCATION_METHODS, ASSIGN_DOM_PROPS, UI_LABEL_KEYS, UI_LABELS_MAX, NOTE_REGEX, NOTES_MAX;
+var import_node_fs18, import_node_path23, tsxLanguage, parserInstance, TreeSitterCtor, initPromise, initialized, queriesDir, queryCache, MAX_PARSEABLE_BYTES, MAX_CONSECUTIVE_PARSE_FAILURES, consecutiveParseFailures, ParseCascadeError, PRISMA_MUTATION_METHODS_BUILTIN, SUPABASE_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods, INLINE_AUTH_IMPORTS, EXEMPT_NAME_PATTERNS, PROTECT_NAME_PATTERNS, TRUST_AS_PROTECT_KEYS, TIMER_FNS, DOM_METHOD_NAMES, CLASSLIST_METHODS, STORAGE_OBJECTS, HISTORY_METHODS, LOCATION_METHODS, ASSIGN_DOM_PROPS, UI_LABEL_KEYS, UI_LABELS_MAX, NOTE_REGEX, NOTES_MAX;
 var init_ts_extractor = __esm({
   "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
-    import_node_fs17 = require("node:fs");
-    import_node_path22 = require("node:path");
+    import_node_fs18 = require("node:fs");
+    import_node_path23 = require("node:path");
     init_parse_failure_cache();
     initialized = false;
     queriesDir = (() => {
-      const srcPath = (0, import_node_path22.join)((0, import_node_path22.dirname)(__filename), "..", "queries");
+      const srcPath = (0, import_node_path23.join)((0, import_node_path23.dirname)(__filename), "..", "queries");
       if (require("fs").existsSync(srcPath)) return srcPath;
-      return (0, import_node_path22.join)((0, import_node_path22.dirname)(__filename), "graph", "queries");
+      return (0, import_node_path23.join)((0, import_node_path23.dirname)(__filename), "graph", "queries");
     })();
     queryCache = /* @__PURE__ */ new Map();
     MAX_PARSEABLE_BYTES = 2 * 1024 * 1024;
@@ -24714,7 +24714,7 @@ __export(watcher_exports, {
 function isIgnoredPath(rel) {
   if (rel.startsWith(GRAPHS_RELATIVE)) return true;
   if (rel.endsWith(".lock") || rel.endsWith(".log")) return true;
-  for (const part of rel.split(import_node_path37.sep)) {
+  for (const part of rel.split(import_node_path38.sep)) {
     if (IGNORE_SEGMENTS.has(part)) return true;
   }
   return false;
@@ -24756,7 +24756,7 @@ function startGraphWatcher(rootDir, opts = {}) {
       regenerating = false;
     }
   }
-  const watcher = (0, import_node_fs29.watch)(rootDir, { recursive: true }, (event, filename) => {
+  const watcher = (0, import_node_fs30.watch)(rootDir, { recursive: true }, (event, filename) => {
     if (!filename) return;
     const rel = filename.toString();
     if (process.env.LAUNCH_CHART_WATCH_TRACE === "1") {
@@ -24789,12 +24789,12 @@ function startGraphWatcher(rootDir, opts = {}) {
     freshness: () => getFreshnessTracker(rootDir).get()
   };
 }
-var import_node_fs29, import_node_path37, IGNORE_SEGMENTS, TRIGGER_EXTENSIONS, GRAPHS_RELATIVE;
+var import_node_fs30, import_node_path38, IGNORE_SEGMENTS, TRIGGER_EXTENSIONS, GRAPHS_RELATIVE;
 var init_watcher = __esm({
   "src/server/graph/core/watcher.ts"() {
     "use strict";
-    import_node_fs29 = require("node:fs");
-    import_node_path37 = require("node:path");
+    import_node_fs30 = require("node:fs");
+    import_node_path38 = require("node:path");
     init_launch_kit_paths();
     init_graph();
     init_freshness();
@@ -24823,7 +24823,7 @@ var init_watcher = __esm({
       ".prisma",
       ".sql"
     ]);
-    GRAPHS_RELATIVE = (0, import_node_path37.join)(LAUNCHSECURE_DIR, "graphs");
+    GRAPHS_RELATIVE = (0, import_node_path38.join)(LAUNCHSECURE_DIR, "graphs");
   }
 });
 
@@ -27836,6 +27836,34 @@ function openInBrowser(url) {
   }
 }
 
+// src/server/radar/credential-store.ts
+var import_node_fs = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path2 = require("node:path");
+function tokenPath() {
+  const home = process.env.HOME ?? (0, import_node_os2.homedir)();
+  return (0, import_node_path2.join)(home, ".claude", ".radar-oauth-token");
+}
+function persistOauthToken(token) {
+  const path13 = tokenPath();
+  (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(path13), { recursive: true });
+  (0, import_node_fs.writeFileSync)(path13, `${token.trim()}
+`, { mode: 384 });
+  (0, import_node_fs.chmodSync)(path13, 384);
+}
+function loadPersistedOauthToken() {
+  const path13 = tokenPath();
+  if (!(0, import_node_fs.existsSync)(path13)) return false;
+  try {
+    const token = (0, import_node_fs.readFileSync)(path13, "utf8").trim();
+    if (!token) return false;
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/server/radar/mcp.ts
 var import_node_https = require("node:https");
 var import_node_http = require("node:http");
@@ -28403,8 +28431,8 @@ async function releaseRegistration(params) {
 }
 
 // src/server/radar/screenshot.ts
-var import_node_fs = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
 init_launch_kit_paths();
 async function fetchScreenshotIfPresent(opts) {
   const { blobId, mcp, projectRoot } = opts;
@@ -28425,11 +28453,11 @@ async function fetchScreenshotIfPresent(opts) {
     return null;
   }
   const ext = payload.contentType?.includes("png") ? "png" : "jpg";
-  const dir = (0, import_node_path2.join)(projectRoot, LAUNCHPOD_DIR, "screenshots");
-  if (!(0, import_node_fs.existsSync)(dir)) (0, import_node_fs.mkdirSync)(dir, { recursive: true });
-  const localPath = (0, import_node_path2.join)(dir, `${blobId}.${ext}`);
+  const dir = (0, import_node_path3.join)(projectRoot, LAUNCHPOD_DIR, "screenshots");
+  if (!(0, import_node_fs2.existsSync)(dir)) (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const localPath = (0, import_node_path3.join)(dir, `${blobId}.${ext}`);
   try {
-    (0, import_node_fs.writeFileSync)(localPath, Buffer.from(payload.dataBase64, "base64"));
+    (0, import_node_fs2.writeFileSync)(localPath, Buffer.from(payload.dataBase64, "base64"));
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
     console.warn(`[radar] screenshot write failed (${blobId}): ${msg}`);
@@ -28439,30 +28467,30 @@ async function fetchScreenshotIfPresent(opts) {
 }
 
 // src/server/radar/state.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = require("node:path");
 init_launch_kit_paths();
 var MAX_DEDUPE_SET = 1e3;
 var MAX_PINGS = 200;
 function readJson(path13, fallback) {
-  if (!(0, import_node_fs2.existsSync)(path13)) return fallback;
+  if (!(0, import_node_fs3.existsSync)(path13)) return fallback;
   try {
-    return JSON.parse((0, import_node_fs2.readFileSync)(path13, "utf-8"));
+    return JSON.parse((0, import_node_fs3.readFileSync)(path13, "utf-8"));
   } catch {
     return fallback;
   }
 }
 function writeJsonAtomic(path13, value) {
-  (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(path13), { recursive: true });
+  (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)(path13), { recursive: true });
   const tmp = `${path13}.tmp.${process.pid}.${Date.now()}`;
-  (0, import_node_fs2.writeFileSync)(tmp, JSON.stringify(value, null, 2), "utf-8");
-  (0, import_node_fs2.renameSync)(tmp, path13);
+  (0, import_node_fs3.writeFileSync)(tmp, JSON.stringify(value, null, 2), "utf-8");
+  (0, import_node_fs3.renameSync)(tmp, path13);
 }
 var RadarState = class {
   constructor(projectRoot) {
-    const dir = (0, import_node_path3.join)(projectRoot, LAUNCHPOD_DIR);
-    this.regPath = (0, import_node_path3.join)(dir, "radar.json");
-    this.pingsPath = (0, import_node_path3.join)(dir, "radar-pings.json");
+    const dir = (0, import_node_path4.join)(projectRoot, LAUNCHPOD_DIR);
+    this.regPath = (0, import_node_path4.join)(dir, "radar.json");
+    this.pingsPath = (0, import_node_path4.join)(dir, "radar-pings.json");
     this.registration = readJson(this.regPath, null);
     this.pingsState = readJson(this.pingsPath, { seenActivityLogIds: [], pings: [] });
     this.migrateLoadedPings();
@@ -28501,9 +28529,9 @@ var RadarState = class {
   }
   clearRegistration() {
     this.registration = null;
-    if ((0, import_node_fs2.existsSync)(this.regPath)) {
+    if ((0, import_node_fs3.existsSync)(this.regPath)) {
       try {
-        (0, import_node_fs2.unlinkSync)(this.regPath);
+        (0, import_node_fs3.unlinkSync)(this.regPath);
       } catch {
       }
     }
@@ -28659,14 +28687,14 @@ var RadarState = class {
 };
 
 // src/server/tunnel/index.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_events = require("node:events");
 var import_promises = require("node:dns/promises");
 
 // ../../node_modules/.pnpm/cacheable-lookup@7.0.0/node_modules/cacheable-lookup/source/index.js
 var import_node_dns = require("node:dns");
 var import_node_util = require("node:util");
-var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
 var { Resolver: AsyncResolver } = import_node_dns.promises;
 var kCacheableLookupCreateConnection = /* @__PURE__ */ Symbol("cacheableLookupCreateConnection");
 var kCacheableLookupInstance = /* @__PURE__ */ Symbol("cacheableLookupInstance");
@@ -28689,7 +28717,7 @@ var map4to6 = (entries) => {
 var getIfaceInfo = () => {
   let has4 = false;
   let has6 = false;
-  for (const device of Object.values(import_node_os2.default.networkInterfaces())) {
+  for (const device of Object.values(import_node_os3.default.networkInterfaces())) {
     for (const iface of device) {
       if (iface.internal) {
         continue;
@@ -29072,7 +29100,7 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
   }
   async start() {
     if (this.tunnel) return;
-    if (!(0, import_node_fs3.existsSync)(import_cloudflared.bin)) {
+    if (!(0, import_node_fs4.existsSync)(import_cloudflared.bin)) {
       console.log("[tunnel] downloading cloudflared binary (one-time setup)\u2026");
       try {
         await (0, import_cloudflared.install)(import_cloudflared.bin);
@@ -29307,6 +29335,9 @@ var Radar = class _Radar {
   start() {
     this.status = "tunneling";
     console.log("[radar] starting cloudflared tunnel\u2026");
+    if (loadPersistedOauthToken()) {
+      console.log("[radar] applied persisted Claude token saved from a previous Config update");
+    }
     this.preflightAuth();
     this.tunnel.on("ready", (publicUrl) => {
       void this.handleTunnelReady(publicUrl);
@@ -29814,32 +29845,88 @@ var Radar = class _Radar {
     if (firstHit) console.error(`[radar] \u2717 auth failure \u2014 ${detail}`);
     this.broadcastStatus();
   }
+  /**
+   * Run a single non-interactive Claude turn and classify the outcome.
+   *   - rejected:     401 / invalid creds / login prompt → the token is dead.
+   *   - inconclusive: binary missing, network, timeout → don't judge the token.
+   *   - ok:           credential accepted.
+   * `envOverride` is layered over process.env for the spawned child — used to
+   * trial a candidate token before committing it. NB: must NOT use `--bare` —
+   * bare mode ignores CLAUDE_CODE_OAUTH_TOKEN.
+   */
+  probeClaudeAuth(envOverride) {
+    return new Promise((resolve7) => {
+      const child = (0, import_node_child_process2.execFile)(
+        "claude",
+        ["-p", "Reply with: ok", "--max-turns", "1"],
+        { timeout: 6e4, maxBuffer: 1 << 20, env: envOverride ? { ...process.env, ...envOverride } : process.env },
+        (err2, stdout, stderr) => {
+          const out = `${stdout ?? ""}
+${stderr ?? ""}`;
+          if (/Please run \/login|Invalid authentication credentials|API Error: 401/i.test(out)) {
+            resolve7({ ok: false, rejected: true, detail: "Claude credential rejected (401)." });
+          } else if (err2 && /timed out|ETIMEDOUT/i.test(String(err2))) {
+            resolve7({ ok: false, rejected: false, detail: "verification timed out." });
+          } else if (err2) {
+            resolve7({ ok: false, rejected: false, detail: err2.message });
+          } else {
+            resolve7({ ok: true, rejected: false, detail: "ok" });
+          }
+        }
+      );
+      child.on("error", (e) => resolve7({ ok: false, rejected: false, detail: `could not spawn claude: ${e.message}` }));
+    });
+  }
   /**
    * Best-effort credential probe at boot. Catches a dead token immediately
    * (raises the banner) instead of only discovering it when the first real ping
    * fails — the failure mode that can leave a pod silently broken for days. Runs
    * a single non-interactive turn. Opt out with RADAR_SKIP_AUTH_PREFLIGHT=1.
-   * NB: must NOT use `--bare` — bare mode ignores CLAUDE_CODE_OAUTH_TOKEN.
    */
   preflightAuth() {
     if (process.env.RADAR_SKIP_AUTH_PREFLIGHT === "1") return;
-    const child = (0, import_node_child_process2.execFile)(
-      "claude",
-      ["-p", "Reply with: ok", "--max-turns", "1"],
-      { timeout: 6e4, maxBuffer: 1 << 20 },
-      (err2, stdout, stderr) => {
-        const out = `${stdout ?? ""}
-${stderr ?? ""}`;
-        if (/Please run \/login|Invalid authentication credentials|API Error: 401/i.test(out)) {
-          this.flagAuthErrorBanner("Boot credential check failed \u2014 Claude credential rejected (401). Regenerate the pod's Claude credentials and restart the pod.");
-        } else if (err2 && !/timed out|ETIMEDOUT/i.test(String(err2))) {
-          console.warn(`[radar] auth preflight inconclusive: ${err2.message}`);
-        } else if (!err2) {
-          console.log("[radar] \u2713 auth preflight passed");
-        }
+    void this.probeClaudeAuth().then((r) => {
+      if (r.rejected) {
+        this.flagAuthErrorBanner("Boot credential check failed \u2014 Claude credential rejected (401). Paste a fresh token in Config (gear icon) to fix it without a redeploy, or regenerate the pod's credentials.");
+      } else if (!r.ok) {
+        console.warn(`[radar] auth preflight inconclusive: ${r.detail}`);
+      } else {
+        console.log("[radar] \u2713 auth preflight passed");
       }
-    );
-    child.on("error", (e) => console.warn(`[radar] auth preflight could not spawn claude: ${e.message}`));
+    });
+  }
+  /**
+   * Operator pasted a fresh long-lived CLAUDE_CODE_OAUTH_TOKEN in the Config
+   * screen. Validate it with a live probe BEFORE committing anything, then:
+   *   - set process.env so every subsequent `claude` spawn (analyzers, the next
+   *     preflight) uses it immediately — no restart, because claude reads the
+   *     env on each run;
+   *   - persist it to the pod's persistent store so it survives a redeploy;
+   *   - clear the auth banner.
+   * Returns {ok:false} WITHOUT changing anything if the token is rejected, so a
+   * bad paste can't replace a working (or recoverable) credential.
+   */
+  async updateClaudeCredential(rawToken) {
+    const token = rawToken.trim();
+    if (!token) return { ok: false, error: "Token is empty." };
+    const probe = await this.probeClaudeAuth({ CLAUDE_CODE_OAUTH_TOKEN: token });
+    if (probe.rejected) {
+      return { ok: false, error: "Claude rejected this token (401). Paste a fresh one from `claude setup-token`." };
+    }
+    if (!probe.ok) {
+      return { ok: false, error: `Could not verify the token \u2014 ${probe.detail} Nothing was changed.` };
+    }
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = token;
+    try {
+      persistOauthToken(token);
+    } catch (err2) {
+      console.warn(`[radar] token applied live but persist failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      this.clearAuthErrorOnRecovery();
+      return { ok: true, error: "Applied for now, but saving it for redeploys failed \u2014 check pod storage permissions." };
+    }
+    console.log("[radar] \u2713 Claude token updated via Config \u2014 applied live and persisted");
+    this.clearAuthErrorOnRecovery();
+    return { ok: true };
   }
   /**
    * A later session authenticated successfully (it produced a summary), so any
@@ -29878,14 +29965,14 @@ function sameStringSet(a, b) {
 }
 
 // src/server/radar/transcript-reader.ts
-var import_node_fs4 = require("node:fs");
-var import_node_os3 = __toESM(require("node:os"));
-var import_node_path4 = __toESM(require("node:path"));
+var import_node_fs5 = require("node:fs");
+var import_node_os4 = __toESM(require("node:os"));
+var import_node_path5 = __toESM(require("node:path"));
 function flattenCwd(absCwd) {
   return absCwd.replace(/\//g, "-");
 }
 function getJsonlPath(projectDir, sessionId) {
-  return import_node_path4.default.join(import_node_os3.default.homedir(), ".claude", "projects", flattenCwd(projectDir), `${sessionId}.jsonl`);
+  return import_node_path5.default.join(import_node_os4.default.homedir(), ".claude", "projects", flattenCwd(projectDir), `${sessionId}.jsonl`);
 }
 var RENDERABLE_TYPES = /* @__PURE__ */ new Set(["user", "assistant", "system"]);
 function parseMetaLine(raw) {
@@ -30002,7 +30089,7 @@ function streamTranscript(opts) {
   const tick = async () => {
     if (cancelled) return;
     try {
-      const stat = await import_node_fs4.promises.stat(filePath).catch(() => null);
+      const stat = await import_node_fs5.promises.stat(filePath).catch(() => null);
       if (!stat) {
         if (!waitingNotified) {
           waitingNotified = true;
@@ -30017,7 +30104,7 @@ function streamTranscript(opts) {
       }
       const jsonlGrew = stat.size > offset;
       if (jsonlGrew) {
-        const fh = await import_node_fs4.promises.open(filePath, "r");
+        const fh = await import_node_fs5.promises.open(filePath, "r");
         try {
           const len = stat.size - offset;
           const buf = Buffer.alloc(len);
@@ -30077,10 +30164,10 @@ function streamTranscript(opts) {
 }
 
 // src/server/graph-mcp.ts
-var import_node_fs30 = require("node:fs");
-var import_node_path38 = require("node:path");
+var import_node_fs31 = require("node:fs");
+var import_node_path39 = require("node:path");
 var import_node_child_process4 = require("node:child_process");
-var import_node_os6 = require("node:os");
+var import_node_os7 = require("node:os");
 init_launch_kit_paths();
 init_graph();
 
@@ -30118,8 +30205,8 @@ export const ${exportName} = {
 }
 
 // src/server/graph/core/context/snippet-registry.ts
-var import_node_fs13 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path18 = require("node:path");
 var DEFAULT_SNIPPETS_DIR = "tests/snippets";
 function parseStringArray(src, key) {
   const m = src.match(new RegExp(`${key}\\s*:\\s*\\[([^\\]]*)\\]`));
@@ -30140,15 +30227,15 @@ function parseSnippetFile(content, file) {
   };
 }
 function loadSnippetIndex(rootDir, snippetsDir = DEFAULT_SNIPPETS_DIR) {
-  const dir = (0, import_node_path17.join)(rootDir, snippetsDir);
+  const dir = (0, import_node_path18.join)(rootDir, snippetsDir);
   const index = /* @__PURE__ */ new Map();
-  if (!(0, import_node_fs13.existsSync)(dir)) return index;
-  for (const f of (0, import_node_fs13.readdirSync)(dir)) {
+  if (!(0, import_node_fs14.existsSync)(dir)) return index;
+  for (const f of (0, import_node_fs14.readdirSync)(dir)) {
     if (!f.endsWith(".ts") && !f.endsWith(".tsx")) continue;
-    const full = (0, import_node_path17.join)(dir, f);
+    const full = (0, import_node_path18.join)(dir, f);
     try {
-      if (!(0, import_node_fs13.statSync)(full).isFile()) continue;
-      const entry = parseSnippetFile((0, import_node_fs13.readFileSync)(full, "utf-8"), (0, import_node_path17.join)(snippetsDir, f));
+      if (!(0, import_node_fs14.statSync)(full).isFile()) continue;
+      const entry = parseSnippetFile((0, import_node_fs14.readFileSync)(full, "utf-8"), (0, import_node_path18.join)(snippetsDir, f));
       if (entry) index.set(entry.id, entry);
     } catch {
     }
@@ -30229,7 +30316,7 @@ function buildTestPlan(graph, targetId, snippets) {
 }
 
 // src/server/graph/core/context/spec-gen.ts
-var import_node_path18 = require("node:path");
+var import_node_path19 = require("node:path");
 function toEnvRef(name) {
   return `process.env.${name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase()}`;
 }
@@ -30246,7 +30333,7 @@ function classify(name) {
   return { kind: "faker", faker: "faker.lorem.word()" };
 }
 function relImport(specDir, file) {
-  let r = (0, import_node_path18.relative)(specDir, file).replace(/\.tsx?$/, "");
+  let r = (0, import_node_path19.relative)(specDir, file).replace(/\.tsx?$/, "");
   if (!r.startsWith(".")) r = `./${r}`;
   return r;
 }
@@ -30297,29 +30384,29 @@ ${[...warnings, ...callLines].join("\n")}
 
 // src/server/lockfile.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs14 = require("node:fs");
-var import_node_os4 = require("node:os");
-var import_node_path19 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_os5 = require("node:os");
+var import_node_path20 = require("node:path");
 init_launch_kit_paths();
 function lockDir(projectRoot) {
   if (projectRoot) {
-    return (0, import_node_path19.join)(projectRoot, LAUNCHSECURE_DIR);
+    return (0, import_node_path20.join)(projectRoot, LAUNCHSECURE_DIR);
   }
-  return (0, import_node_path19.join)((0, import_node_os4.homedir)(), LAUNCHSECURE_DIR);
+  return (0, import_node_path20.join)((0, import_node_os5.homedir)(), LAUNCHSECURE_DIR);
 }
 function lockPath(projectRoot) {
-  return (0, import_node_path19.join)(lockDir(projectRoot), "launch-chart.lock");
+  return (0, import_node_path20.join)(lockDir(projectRoot), "launch-chart.lock");
 }
 var _activeProjectRoot;
 function readLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   const p = lockPath(root);
-  if (!(0, import_node_fs14.existsSync)(p)) {
+  if (!(0, import_node_fs15.existsSync)(p)) {
     if (root) {
       const globalP = lockPath();
-      if ((0, import_node_fs14.existsSync)(globalP)) {
+      if ((0, import_node_fs15.existsSync)(globalP)) {
         try {
-          const data = JSON.parse((0, import_node_fs14.readFileSync)(globalP, "utf-8"));
+          const data = JSON.parse((0, import_node_fs15.readFileSync)(globalP, "utf-8"));
           if (typeof data.pid === "number" && typeof data.port === "number" && data.cwd === root) {
             return data;
           }
@@ -30330,7 +30417,7 @@ function readLock(projectRoot) {
     return null;
   }
   try {
-    const data = JSON.parse((0, import_node_fs14.readFileSync)(p, "utf-8"));
+    const data = JSON.parse((0, import_node_fs15.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
     return data;
   } catch {
@@ -30367,7 +30454,7 @@ function getLiveLock(projectRoot) {
   const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
   if (!live) {
     try {
-      (0, import_node_fs14.unlinkSync)(lockPath(root));
+      (0, import_node_fs15.unlinkSync)(lockPath(root));
     } catch {
     }
     return null;
@@ -30377,7 +30464,7 @@ function getLiveLock(projectRoot) {
 function clearLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   try {
-    (0, import_node_fs14.unlinkSync)(lockPath(root));
+    (0, import_node_fs15.unlinkSync)(lockPath(root));
   } catch {
   }
 }
@@ -30386,20 +30473,20 @@ function clearLock(projectRoot) {
 init_config();
 
 // src/server/graph/core/parser-registry.ts
-var import_node_path30 = require("node:path");
+var import_node_path31 = require("node:path");
 
 // src/server/graph/parsers/ts/typescript-project.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path23 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_path24 = require("node:path");
 init_config();
 
 // src/server/graph/core/resolve-paths.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path22 = require("node:path");
 
 // src/server/graph/core/walk.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path21 = require("node:path");
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -30409,12 +30496,12 @@ var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
 ]);
 function walk(dir, exts) {
   const results = [];
-  if (!(0, import_node_fs15.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path20.join)(dir, entry.name);
+  if (!(0, import_node_fs16.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path21.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path20.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path21.extname)(entry.name))) {
       results.push(full);
     }
   }
@@ -30422,15 +30509,15 @@ function walk(dir, exts) {
 }
 function walkWithIgnore(dir, exts, opts = {}) {
   const results = [];
-  if (!(0, import_node_fs15.existsSync)(dir)) return results;
+  if (!(0, import_node_fs16.existsSync)(dir)) return results;
   const skip = opts.extraIgnore ? /* @__PURE__ */ new Set([...DEFAULT_IGNORE_DIRS, ...opts.extraIgnore]) : DEFAULT_IGNORE_DIRS;
-  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".")) continue;
       if (skip.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path20.join)(dir, entry.name), exts, opts));
-    } else if (exts.includes((0, import_node_path20.extname)(entry.name))) {
-      results.push((0, import_node_path20.join)(dir, entry.name));
+      results.push(...walkWithIgnore((0, import_node_path21.join)(dir, entry.name), exts, opts));
+    } else if (exts.includes((0, import_node_path21.extname)(entry.name))) {
+      results.push((0, import_node_path21.join)(dir, entry.name));
     }
   }
   return results;
@@ -30438,9 +30525,9 @@ function walkWithIgnore(dir, exts, opts = {}) {
 
 // src/server/graph/core/resolve-paths.ts
 function hasSqlFiles(dir) {
-  if (!(0, import_node_fs16.existsSync)(dir)) return false;
+  if (!(0, import_node_fs17.existsSync)(dir)) return false;
   try {
-    return (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true }).some(
+    return (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true }).some(
       (e) => e.isFile() && e.name.endsWith(".sql")
     );
   } catch {
@@ -30448,27 +30535,27 @@ function hasSqlFiles(dir) {
   }
 }
 function hasNestedMigrationSql(dir) {
-  if (!(0, import_node_fs16.existsSync)(dir)) return false;
+  if (!(0, import_node_fs17.existsSync)(dir)) return false;
   try {
-    return (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true }).some(
-      (e) => e.isDirectory() && (0, import_node_fs16.existsSync)((0, import_node_path21.join)(dir, e.name, "migration.sql"))
+    return (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isDirectory() && (0, import_node_fs17.existsSync)((0, import_node_path22.join)(dir, e.name, "migration.sql"))
     );
   } catch {
     return false;
   }
 }
 function resolveDbFromDir(dir) {
-  if (!(0, import_node_fs16.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
-  const schemaPath = (0, import_node_path21.join)(dir, "schema.prisma");
-  if ((0, import_node_fs16.existsSync)(schemaPath)) {
-    const migrationsDir2 = (0, import_node_path21.join)(dir, "migrations");
+  if (!(0, import_node_fs17.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
+  const schemaPath = (0, import_node_path22.join)(dir, "schema.prisma");
+  if ((0, import_node_fs17.existsSync)(schemaPath)) {
+    const migrationsDir2 = (0, import_node_path22.join)(dir, "migrations");
     return {
       kind: "prisma",
       schemaPath,
-      migrationsDir: (0, import_node_fs16.existsSync)(migrationsDir2) ? migrationsDir2 : null
+      migrationsDir: (0, import_node_fs17.existsSync)(migrationsDir2) ? migrationsDir2 : null
     };
   }
-  const migrationsDir = (0, import_node_path21.join)(dir, "migrations");
+  const migrationsDir = (0, import_node_path22.join)(dir, "migrations");
   if (hasSqlFiles(migrationsDir) || hasNestedMigrationSql(migrationsDir)) {
     return { kind: "sql-migrations", migrationsDir, schemaPath: null };
   }
@@ -30479,19 +30566,19 @@ function resolveDbFromDir(dir) {
 }
 function detectDbConfig(rootDir, config) {
   if (config.paths?.dbDir) {
-    return resolveDbFromDir((0, import_node_path21.join)(rootDir, config.paths.dbDir));
+    return resolveDbFromDir((0, import_node_path22.join)(rootDir, config.paths.dbDir));
   }
-  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path21.join)("db", "migrations"), "migrations"];
+  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path22.join)("db", "migrations"), "migrations"];
   for (const c of candidates) {
-    const dir = (0, import_node_path21.join)(rootDir, c);
+    const dir = (0, import_node_path22.join)(rootDir, c);
     const resolved = resolveDbFromDir(dir);
     if (resolved.kind !== "none") return resolved;
   }
   return { kind: "none", schemaPath: null, migrationsDir: null };
 }
 function detectDbDir(rootDir, config, dbConfig) {
-  if (config.paths?.dbDir) return (0, import_node_path21.join)(rootDir, config.paths.dbDir);
-  if (dbConfig.kind === "prisma") return (0, import_node_path21.dirname)(dbConfig.schemaPath);
+  if (config.paths?.dbDir) return (0, import_node_path22.join)(rootDir, config.paths.dbDir);
+  if (dbConfig.kind === "prisma") return (0, import_node_path22.dirname)(dbConfig.schemaPath);
   if (dbConfig.kind === "sql-migrations") return dbConfig.migrationsDir;
   return null;
 }
@@ -30522,16 +30609,16 @@ var NON_SOURCE_DIRS = /* @__PURE__ */ new Set([
   "libs"
 ]);
 function dirHasTSFiles(dir) {
-  if (!(0, import_node_fs16.existsSync)(dir)) return false;
+  if (!(0, import_node_fs17.existsSync)(dir)) return false;
   try {
     const stack = [dir];
     while (stack.length > 0) {
       const cur = stack.pop();
-      const entries = (0, import_node_fs16.readdirSync)(cur, { withFileTypes: true });
+      const entries = (0, import_node_fs17.readdirSync)(cur, { withFileTypes: true });
       for (const e of entries) {
         if (e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx"))) return true;
         if (e.isDirectory() && !e.name.startsWith(".") && !DEFAULT_IGNORE_DIRS.has(e.name)) {
-          stack.push((0, import_node_path21.join)(cur, e.name));
+          stack.push((0, import_node_path22.join)(cur, e.name));
         }
       }
     }
@@ -30540,15 +30627,15 @@ function dirHasTSFiles(dir) {
   return false;
 }
 function collectCodeBearingChildren(dir, extraSkip) {
-  if (!(0, import_node_fs16.existsSync)(dir)) return [];
+  if (!(0, import_node_fs17.existsSync)(dir)) return [];
   const out = [];
   try {
-    for (const entry of (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       if (NON_SOURCE_DIRS.has(entry.name)) continue;
       if (extraSkip?.has(entry.name)) continue;
-      const full = (0, import_node_path21.join)(dir, entry.name);
+      const full = (0, import_node_path22.join)(dir, entry.name);
       if (dirHasTSFiles(full)) out.push(full);
     }
   } catch {
@@ -30560,7 +30647,7 @@ function detectSrcRoots(rootDir, srcDir, appDir, config) {
     const roots2 = /* @__PURE__ */ new Set();
     roots2.add(appDir);
     for (const r of config.paths.srcRoots) {
-      const abs = (0, import_node_path21.isAbsolute)(r) ? r : (0, import_node_path21.resolve)(rootDir, r);
+      const abs = (0, import_node_path22.isAbsolute)(r) ? r : (0, import_node_path22.resolve)(rootDir, r);
       roots2.add(abs);
     }
     return [...roots2];
@@ -30569,7 +30656,7 @@ function detectSrcRoots(rootDir, srcDir, appDir, config) {
   roots.add(appDir);
   for (const c of collectCodeBearingChildren(srcDir)) roots.add(c);
   if (srcDir !== rootDir) {
-    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path21.basename)(srcDir)]);
+    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path22.basename)(srcDir)]);
     for (const c of collectCodeBearingChildren(rootDir, skipSrcWrapper)) roots.add(c);
   }
   return [...roots];
@@ -30581,10 +30668,10 @@ function detectConventionFiles(rootDir, srcDir) {
   const dirs = srcDir === rootDir ? [rootDir] : [srcDir, rootDir];
   for (const dir of dirs) {
     for (const name of CONVENTION_NAMES) {
-      const full = (0, import_node_path21.join)(dir, name);
-      if (!seen.has(full) && (0, import_node_fs16.existsSync)(full)) {
+      const full = (0, import_node_path22.join)(dir, name);
+      if (!seen.has(full) && (0, import_node_fs17.existsSync)(full)) {
         try {
-          if ((0, import_node_fs16.statSync)(full).isFile()) {
+          if ((0, import_node_fs17.statSync)(full).isFile()) {
             seen.add(full);
             out.push(full);
           }
@@ -30599,22 +30686,22 @@ function resolveProjectPaths(rootDir, config) {
   let srcDir;
   let appDir;
   if (config.paths?.appDir) {
-    appDir = (0, import_node_path21.join)(rootDir, config.paths.appDir);
-    srcDir = config.paths.srcDir ? (0, import_node_path21.join)(rootDir, config.paths.srcDir) : (0, import_node_path21.dirname)(appDir);
+    appDir = (0, import_node_path22.join)(rootDir, config.paths.appDir);
+    srcDir = config.paths.srcDir ? (0, import_node_path22.join)(rootDir, config.paths.srcDir) : (0, import_node_path22.dirname)(appDir);
   } else {
-    const srcApp = (0, import_node_path21.join)(rootDir, "src", "app");
-    const rootApp = (0, import_node_path21.join)(rootDir, "app");
-    if ((0, import_node_fs16.existsSync)(srcApp)) {
-      srcDir = (0, import_node_path21.join)(rootDir, "src");
+    const srcApp = (0, import_node_path22.join)(rootDir, "src", "app");
+    const rootApp = (0, import_node_path22.join)(rootDir, "app");
+    if ((0, import_node_fs17.existsSync)(srcApp)) {
+      srcDir = (0, import_node_path22.join)(rootDir, "src");
       appDir = srcApp;
-    } else if ((0, import_node_fs16.existsSync)(rootApp)) {
+    } else if ((0, import_node_fs17.existsSync)(rootApp)) {
       srcDir = rootDir;
       appDir = rootApp;
     } else {
       return null;
     }
   }
-  const apiDir = (0, import_node_path21.join)(appDir, "api");
+  const apiDir = (0, import_node_path22.join)(appDir, "api");
   const dbConfig = detectDbConfig(rootDir, config);
   const dbDir = detectDbDir(rootDir, config, dbConfig);
   const srcRoots = detectSrcRoots(rootDir, srcDir, appDir, config);
@@ -30641,25 +30728,25 @@ var CLASSIFICATION_TO_LAYER = {
   external: "ui"
 };
 function toNodeId(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path23.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path24.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path23.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path24.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
   const rel = specifier.slice(2);
-  const base = (0, import_node_path23.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path23.join)(base, "index.ts"), (0, import_node_path23.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs18.existsSync)(c) && (0, import_node_fs18.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path24.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path24.join)(base, "index.ts"), (0, import_node_path24.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs19.existsSync)(c) && (0, import_node_fs19.statSync)(c).isFile()) return c;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path23.join)((0, import_node_path23.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path23.join)(base, "index.ts"), (0, import_node_path23.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs18.existsSync)(c) && (0, import_node_fs18.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path24.join)((0, import_node_path24.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path24.join)(base, "index.ts"), (0, import_node_path24.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs19.existsSync)(c) && (0, import_node_fs19.statSync)(c).isFile()) return c;
   }
   return null;
 }
@@ -30680,7 +30767,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path23.basename)(resolved);
+      const targetBn = (0, import_node_path24.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -30707,12 +30794,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_path23.basename)(absPath);
+    const bn = (0, import_node_path24.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_path23.relative)(srcDir, (0, import_node_path23.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path24.relative)(srcDir, (0, import_node_path24.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -30737,10 +30824,10 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path23.basename)(absPath, (0, import_node_path23.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  return (0, import_node_path24.basename)(absPath, (0, import_node_path24.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
 function filePathToAppRoute(appDir, absPath) {
-  let route = ("/" + (0, import_node_path23.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
+  let route = ("/" + (0, import_node_path24.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
   route = route.replace(/\/\([^)]+\)/g, "");
   route = route.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "*$1?");
   route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
@@ -30988,7 +31075,7 @@ function generate(rootDir) {
   const apiNodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const routeToNodeId = /* @__PURE__ */ new Map();
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path23.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path24.basename)(f).startsWith("index."));
   for (const absPath of fileSet) {
     const id = toNodeId(srcDir, rootDir, absPath);
     const type = classifyType(absPath, id);
@@ -31148,7 +31235,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path23.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path24.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -31498,7 +31585,7 @@ var typescriptProjectParser = {
 };
 
 // src/server/graph/parsers/db/prisma-schema.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs20 = require("node:fs");
 init_config();
 function parseModels(content) {
   const nodes = [];
@@ -31591,7 +31678,7 @@ function parseEnums(content) {
 }
 function detect2(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs19.existsSync)(paths.dbConfig.schemaPath);
+  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs20.existsSync)(paths.dbConfig.schemaPath);
 }
 function generate2(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
@@ -31608,7 +31695,7 @@ function generate2(rootDir) {
     };
   }
   const schemaPath = paths.dbConfig.schemaPath;
-  const content = (0, import_node_fs19.readFileSync)(schemaPath, "utf-8");
+  const content = (0, import_node_fs20.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -31665,8 +31752,8 @@ var prismaSchemaParser = {
 };
 
 // src/server/graph/parsers/db/sql-migrations.ts
-var import_node_fs20 = require("node:fs");
-var import_node_path24 = require("node:path");
+var import_node_fs21 = require("node:fs");
+var import_node_path25 = require("node:path");
 var import_pgsql_parser = require("pgsql-parser");
 init_config();
 var PG_TO_PRISMA = {
@@ -31700,15 +31787,15 @@ function pgTypeToPrisma(pgType) {
   return PG_TO_PRISMA[upper] ?? upper;
 }
 function discoverMigrationFiles(migrationsDir) {
-  if (!(0, import_node_fs20.existsSync)(migrationsDir)) return [];
+  if (!(0, import_node_fs21.existsSync)(migrationsDir)) return [];
   const out = [];
-  const entries = (0, import_node_fs20.readdirSync)(migrationsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = (0, import_node_fs21.readdirSync)(migrationsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const sqlPath = (0, import_node_path24.join)(migrationsDir, entry.name, "migration.sql");
-      if ((0, import_node_fs20.existsSync)(sqlPath)) out.push(sqlPath);
+      const sqlPath = (0, import_node_path25.join)(migrationsDir, entry.name, "migration.sql");
+      if ((0, import_node_fs21.existsSync)(sqlPath)) out.push(sqlPath);
     } else if (entry.isFile() && entry.name.endsWith(".sql")) {
-      out.push((0, import_node_path24.join)(migrationsDir, entry.name));
+      out.push((0, import_node_path25.join)(migrationsDir, entry.name));
     }
   }
   return out;
@@ -31753,7 +31840,7 @@ function parseMigrations(migrationsDir, dialect = postgresDialect) {
   };
   if (!migrationsDir) return state;
   for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
-    const sql = (0, import_node_fs20.readFileSync)(sqlPath, "utf-8");
+    const sql = (0, import_node_fs21.readFileSync)(sqlPath, "utf-8");
     let ast;
     try {
       ast = dialect.parse(sql);
@@ -32322,8 +32409,8 @@ function indexIsPrismaUncoverable(idx) {
   return idx.hasPredicate || idx.hasExpressions || idx.method !== "btree";
 }
 function loadPrismaState(schemaPath) {
-  if (!schemaPath || !(0, import_node_fs20.existsSync)(schemaPath)) return null;
-  const content = (0, import_node_fs20.readFileSync)(schemaPath, "utf-8");
+  if (!schemaPath || !(0, import_node_fs21.existsSync)(schemaPath)) return null;
+  const content = (0, import_node_fs21.readFileSync)(schemaPath, "utf-8");
   const tables = /* @__PURE__ */ new Map();
   const enums = /* @__PURE__ */ new Map();
   const relations = [];
@@ -32730,7 +32817,7 @@ function generate3(rootDir) {
   const migrationFiles = migrationsDir ? discoverMigrationFiles(migrationsDir) : [];
   let migrationNodeCount = 0;
   for (const sqlPath of migrationFiles) {
-    const sql = (0, import_node_fs20.readFileSync)(sqlPath, "utf-8");
+    const sql = (0, import_node_fs21.readFileSync)(sqlPath, "utf-8");
     const name = deriveMigrationName(sqlPath);
     let ast;
     try {
@@ -33048,14 +33135,14 @@ var fetchResolverParser = {
 };
 
 // src/server/graph/parsers/crosslayer/api-annotations.ts
-var import_node_fs21 = require("node:fs");
-var import_node_path25 = require("node:path");
+var import_node_fs22 = require("node:fs");
+var import_node_path26 = require("node:path");
 init_config();
 var API_ANNOTATION_RE = /@api\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S+)/g;
 function toNodeId2(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path25.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path26.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path25.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path26.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -33100,7 +33187,7 @@ var apiAnnotationsParser = {
     const flaggedEdges = [];
     const seenEdge = /* @__PURE__ */ new Set();
     for (const absPath of files) {
-      const content = (0, import_node_fs21.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs22.readFileSync)(absPath, "utf-8");
       const sourceId = toNodeId2(srcDir, rootDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
       let match;
@@ -33144,14 +33231,14 @@ var apiAnnotationsParser = {
 };
 
 // src/server/graph/parsers/crosslayer/url-literal-scanner.ts
-var import_node_fs22 = require("node:fs");
-var import_node_path26 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path27 = require("node:path");
 init_config();
 var URL_LITERAL_RE = /['"`](\/[a-zA-Z][^'"`\s]*?)['"`]/g;
 function toNodeId3(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path26.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path27.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path26.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path27.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -33195,7 +33282,7 @@ var urlLiteralScannerParser = {
     for (const absPath of files) {
       const sourceId = toNodeId3(srcDir, rootDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
-      const content = (0, import_node_fs22.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs23.readFileSync)(absPath, "utf-8");
       let match;
       URL_LITERAL_RE.lastIndex = 0;
       while ((match = URL_LITERAL_RE.exec(content)) !== null) {
@@ -33226,8 +33313,8 @@ var urlLiteralScannerParser = {
 };
 
 // src/server/graph/parsers/static/static-values.ts
-var import_node_fs23 = require("node:fs");
-var import_node_path27 = require("node:path");
+var import_node_fs24 = require("node:fs");
+var import_node_path28 = require("node:path");
 init_config();
 var parseCode = null;
 function tryLoadTreeSitter() {
@@ -33264,21 +33351,21 @@ function extractEnumValues(rootDir) {
   const schemaPaths = [];
   if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath) {
     schemaPaths.push(paths.dbConfig.schemaPath);
-    schemaPaths.push((0, import_node_path27.join)((0, import_node_path27.dirname)(paths.dbConfig.schemaPath), "schema"));
+    schemaPaths.push((0, import_node_path28.join)((0, import_node_path28.dirname)(paths.dbConfig.schemaPath), "schema"));
   } else {
-    schemaPaths.push((0, import_node_path27.join)(rootDir, "prisma", "schema.prisma"));
-    schemaPaths.push((0, import_node_path27.join)(rootDir, "prisma", "schema"));
+    schemaPaths.push((0, import_node_path28.join)(rootDir, "prisma", "schema.prisma"));
+    schemaPaths.push((0, import_node_path28.join)(rootDir, "prisma", "schema"));
   }
   let content = "";
   for (const p of schemaPaths) {
-    if ((0, import_node_fs23.existsSync)(p)) {
+    if ((0, import_node_fs24.existsSync)(p)) {
       try {
-        const stat = (0, import_node_fs23.statSync)(p);
+        const stat = (0, import_node_fs24.statSync)(p);
         if (stat.isFile()) {
-          content = (0, import_node_fs23.readFileSync)(p, "utf-8");
+          content = (0, import_node_fs24.readFileSync)(p, "utf-8");
         } else if (stat.isDirectory()) {
-          const files = (0, import_node_fs23.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
-          content = files.map((f) => (0, import_node_fs23.readFileSync)((0, import_node_path27.join)(p, f), "utf-8")).join("\n");
+          const files = (0, import_node_fs24.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
+          content = files.map((f) => (0, import_node_fs24.readFileSync)((0, import_node_path28.join)(p, f), "utf-8")).join("\n");
         }
       } catch {
         continue;
@@ -33436,27 +33523,27 @@ function extractSeedData(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
   const candidates = [];
   if (paths?.dbDir) {
-    candidates.push((0, import_node_path27.join)(paths.dbDir, "seed.ts"));
-    candidates.push((0, import_node_path27.join)(paths.dbDir, "seed.js"));
+    candidates.push((0, import_node_path28.join)(paths.dbDir, "seed.ts"));
+    candidates.push((0, import_node_path28.join)(paths.dbDir, "seed.js"));
   } else {
-    candidates.push((0, import_node_path27.join)(rootDir, "prisma", "seed.ts"));
-    candidates.push((0, import_node_path27.join)(rootDir, "prisma", "seed.js"));
+    candidates.push((0, import_node_path28.join)(rootDir, "prisma", "seed.ts"));
+    candidates.push((0, import_node_path28.join)(rootDir, "prisma", "seed.js"));
   }
-  const baseRoots = paths?.srcRoots ?? [(0, import_node_path27.join)(rootDir, "src")];
+  const baseRoots = paths?.srcRoots ?? [(0, import_node_path28.join)(rootDir, "src")];
   for (const root of baseRoots) {
-    candidates.push((0, import_node_path27.join)(root, "server", "lib", "system-tags.ts"));
+    candidates.push((0, import_node_path28.join)(root, "server", "lib", "system-tags.ts"));
   }
   const seedFiles = candidates.filter((p) => {
     try {
-      return (0, import_node_fs23.existsSync)(p) && (0, import_node_fs23.statSync)(p).isFile();
+      return (0, import_node_fs24.existsSync)(p) && (0, import_node_fs24.statSync)(p).isFile();
     } catch {
       return false;
     }
   });
   const useTreeSitter = tryLoadTreeSitter();
   for (const filePath of seedFiles) {
-    const content = (0, import_node_fs23.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path27.relative)(rootDir, filePath);
+    const content = (0, import_node_fs24.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path28.relative)(rootDir, filePath);
     const seeded = detectSeededArrays(content, relPath);
     let astRoot = null;
     if (useTreeSitter && parseCode) {
@@ -33550,11 +33637,11 @@ function extractSeedData(rootDir) {
   return { nodes, edges };
 }
 function walkDir(dir, exts) {
-  if (!(0, import_node_fs23.existsSync)(dir)) return [];
+  if (!(0, import_node_fs24.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs23.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs24.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
-    const full = (0, import_node_path27.join)(dir, entry.name);
+    const full = (0, import_node_path28.join)(dir, entry.name);
     if (entry.isDirectory()) results.push(...walkDir(full, exts));
     else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(full);
   }
@@ -33563,7 +33650,7 @@ function walkDir(dir, exts) {
 function extractConstants(rootDir) {
   const nodes = [];
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  const roots = paths?.srcRoots ?? [(0, import_node_path27.join)(rootDir, "src")];
+  const roots = paths?.srcRoots ?? [(0, import_node_path28.join)(rootDir, "src")];
   const seenFile = /* @__PURE__ */ new Set();
   const allFiles = [];
   for (const root of roots) {
@@ -33576,8 +33663,8 @@ function extractConstants(rootDir) {
   }
   if (allFiles.length === 0) return { nodes };
   for (const filePath of allFiles) {
-    const content = (0, import_node_fs23.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path27.relative)(rootDir, filePath);
+    const content = (0, import_node_fs24.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path28.relative)(rootDir, filePath);
     const constArrayRe = /export\s+const\s+([A-Z][A-Z_0-9]+)\s*(?::[^=]+)?\s*=\s*\[/g;
     let cm;
     while ((cm = constArrayRe.exec(content)) !== null) {
@@ -33611,13 +33698,13 @@ function extractConstants(rootDir) {
 }
 function detect4(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs23.existsSync)(paths.dbConfig.schemaPath)) {
+  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs24.existsSync)(paths.dbConfig.schemaPath)) {
     return true;
   }
   if (paths?.dbDir) {
-    if ((0, import_node_fs23.existsSync)((0, import_node_path27.join)(paths.dbDir, "seed.ts")) || (0, import_node_fs23.existsSync)((0, import_node_path27.join)(paths.dbDir, "seed.js"))) return true;
+    if ((0, import_node_fs24.existsSync)((0, import_node_path28.join)(paths.dbDir, "seed.ts")) || (0, import_node_fs24.existsSync)((0, import_node_path28.join)(paths.dbDir, "seed.js"))) return true;
   }
-  return (0, import_node_fs23.existsSync)((0, import_node_path27.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs23.existsSync)((0, import_node_path27.join)(rootDir, "prisma", "seed.ts"));
+  return (0, import_node_fs24.existsSync)((0, import_node_path28.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs24.existsSync)((0, import_node_path28.join)(rootDir, "prisma", "seed.ts"));
 }
 function generate4(rootDir) {
   const enumResult = extractEnumValues(rootDir);
@@ -33692,8 +33779,8 @@ var staticValuesParser = {
 };
 
 // src/server/graph/parsers/crosslayer/static-ref-scanner.ts
-var import_node_fs24 = require("node:fs");
-var import_node_path28 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_path29 = require("node:path");
 init_config();
 var MIN_VALUE_LENGTH = 4;
 var SKIP_VALUES = /* @__PURE__ */ new Set([
@@ -33868,11 +33955,11 @@ var staticRefScannerParser = {
     const seen = /* @__PURE__ */ new Set();
     let filesScanned = 0;
     for (const absPath of files) {
-      const relFromSrc = (0, import_node_path28.relative)(srcDir, absPath).replace(/\\/g, "/");
-      const sourceId = relFromSrc.startsWith("..") ? (0, import_node_path28.relative)(rootDir, absPath).replace(/\\/g, "/") : relFromSrc;
+      const relFromSrc = (0, import_node_path29.relative)(srcDir, absPath).replace(/\\/g, "/");
+      const sourceId = relFromSrc.startsWith("..") ? (0, import_node_path29.relative)(rootDir, absPath).replace(/\\/g, "/") : relFromSrc;
       const sourceLayer = uiNodeIds.has(sourceId) ? "ui" : apiNodeIds.has(sourceId) ? "api" : null;
       if (!sourceLayer) continue;
-      const content = (0, import_node_fs24.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs25.readFileSync)(absPath, "utf-8");
       filesScanned++;
       let fileRefs;
       if (parseCode2) {
@@ -33914,13 +34001,13 @@ var staticRefScannerParser = {
 };
 
 // src/server/graph/parsers/crosslayer/middleware-gates.ts
-var import_node_path29 = require("node:path");
+var import_node_path30 = require("node:path");
 init_ts_extractor();
 init_config();
 function toNodeId4(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path29.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path30.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path29.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path30.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -34222,7 +34309,7 @@ function registerBuiltins3(registry, disabled) {
 function loadCustomParsers(registry, config, rootDir, disabled) {
   for (const entry of config.parsers?.custom ?? []) {
     try {
-      const absPath = (0, import_node_path30.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path31.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const parser = "default" in mod ? mod.default : mod;
       if (disabled.has(parser.id)) continue;
@@ -34251,8 +34338,8 @@ function createRegistry(config, rootDir) {
 }
 
 // src/server/graph/core/language-detection.ts
-var import_node_fs25 = require("node:fs");
-var import_node_path31 = require("node:path");
+var import_node_fs26 = require("node:fs");
+var import_node_path32 = require("node:path");
 init_launch_kit_paths();
 var EXTENSION_TO_LANGUAGE = {
   // Web / Frontend
@@ -34365,10 +34452,10 @@ var AUXILIARY_LANGUAGES = /* @__PURE__ */ new Set([
 ]);
 function walkForExtensions(dir, extCounts, depth = 0) {
   if (depth > 10) return;
-  if (!(0, import_node_fs25.existsSync)(dir)) return;
+  if (!(0, import_node_fs26.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs25.readdirSync)(dir, { withFileTypes: true });
+    entries = (0, import_node_fs26.readdirSync)(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -34376,9 +34463,9 @@ function walkForExtensions(dir, extCounts, depth = 0) {
     if (entry.name.startsWith(".") && entry.isDirectory()) continue;
     if (entry.isDirectory()) {
       if (IGNORE_DIRS.has(entry.name)) continue;
-      walkForExtensions((0, import_node_path31.join)(dir, entry.name), extCounts, depth + 1);
+      walkForExtensions((0, import_node_path32.join)(dir, entry.name), extCounts, depth + 1);
     } else {
-      const ext = (0, import_node_path31.extname)(entry.name).toLowerCase();
+      const ext = (0, import_node_path32.extname)(entry.name).toLowerCase();
       if (ext && EXTENSION_TO_LANGUAGE[ext]) {
         extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
       }
@@ -34419,13 +34506,13 @@ function detectLanguages(rootDir, supportedLanguages) {
 }
 
 // src/server/graph/core/audit-core.ts
-var import_node_fs27 = require("node:fs");
-var import_node_path33 = require("node:path");
+var import_node_fs28 = require("node:fs");
+var import_node_path34 = require("node:path");
 init_launch_kit_paths();
 
 // src/server/graph/core/audit-security.ts
-var import_node_fs26 = require("node:fs");
-var import_node_path32 = require("node:path");
+var import_node_fs27 = require("node:fs");
+var import_node_path33 = require("node:path");
 init_ts_extractor();
 init_config();
 function collectSourceFiles(rootDir) {
@@ -34450,9 +34537,9 @@ function collectSourceFiles(rootDir) {
   return out;
 }
 function toNodeId5(rootDir, srcDir, absPath) {
-  const relFromSrc = (0, import_node_path32.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path33.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path32.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path33.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -34562,18 +34649,18 @@ function collectDeclaredEnvKeys(rootDir) {
   const files = [];
   let entries = [];
   try {
-    entries = (0, import_node_fs26.readdirSync)(rootDir);
+    entries = (0, import_node_fs27.readdirSync)(rootDir);
   } catch {
     return { keys, files };
   }
   for (const name of entries) {
     if (!name.startsWith(".env")) continue;
-    const abs = (0, import_node_path32.join)(rootDir, name);
-    if (!(0, import_node_fs26.existsSync)(abs)) continue;
+    const abs = (0, import_node_path33.join)(rootDir, name);
+    if (!(0, import_node_fs27.existsSync)(abs)) continue;
     files.push(name);
     let content = "";
     try {
-      content = (0, import_node_fs26.readFileSync)(abs, "utf-8");
+      content = (0, import_node_fs27.readFileSync)(abs, "utf-8");
     } catch {
       continue;
     }
@@ -34760,10 +34847,10 @@ function checkHardcodedUrlFallback(rootDir, core) {
 
 // src/server/graph/core/audit-core.ts
 function readGraphFile(rootDir, layer) {
-  const filePath = (0, import_node_path33.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
-  if (!(0, import_node_fs27.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path34.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
+  if (!(0, import_node_fs28.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs27.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs28.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -34805,15 +34892,15 @@ function checkUnprotectedRoutes(rootDir) {
   const findings = [];
   const api = readGraphFile(rootDir, "api");
   if (!api) return buildSkipped("api", "unprotected_routes", "no api graph");
-  const routePermsPath = (0, import_node_path33.join)(rootDir, "src", "config", "route-permissions.ts");
-  if (!(0, import_node_fs27.existsSync)(routePermsPath)) {
+  const routePermsPath = (0, import_node_path34.join)(rootDir, "src", "config", "route-permissions.ts");
+  if (!(0, import_node_fs28.existsSync)(routePermsPath)) {
     return buildSkipped(
       "api",
       "unprotected_routes",
       `no src/config/route-permissions.ts \u2014 this check needs a centralized ROUTE_PERMISSIONS inventory to compare endpoints against`
     );
   }
-  const routePermsContent = (0, import_node_fs27.readFileSync)(routePermsPath, "utf-8");
+  const routePermsContent = (0, import_node_fs28.readFileSync)(routePermsPath, "utf-8");
   const registeredRoutes = /* @__PURE__ */ new Set();
   const routeEntryRe = /path:\s*'([^']+)'/g;
   let rm;
@@ -34898,15 +34985,15 @@ function checkUnenforcedPermissions(rootDir) {
       `no seed_permission nodes \u2014 this project either has no seed permissions or hasn't tagged them in seed.ts`
     );
   }
-  const routePermsPath = (0, import_node_path33.join)(rootDir, "src", "config", "route-permissions.ts");
-  if (!(0, import_node_fs27.existsSync)(routePermsPath)) {
+  const routePermsPath = (0, import_node_path34.join)(rootDir, "src", "config", "route-permissions.ts");
+  if (!(0, import_node_fs28.existsSync)(routePermsPath)) {
     return buildSkipped(
       "static",
       "unenforced_permissions",
       `no src/config/route-permissions.ts to compare seed permissions against`
     );
   }
-  const routePermsContent = (0, import_node_fs27.readFileSync)(routePermsPath, "utf-8");
+  const routePermsContent = (0, import_node_fs28.readFileSync)(routePermsPath, "utf-8");
   for (const perm of permissions) {
     const regex = new RegExp(`permission:\\s*['"]${perm.key}['"]`);
     if (!regex.test(routePermsContent)) {
@@ -34942,9 +35029,9 @@ function checkHardcodedValues(rootDir) {
   const seen = /* @__PURE__ */ new Set();
   for (const node of api.nodes) {
     if (node.type !== "endpoint") continue;
-    const filePath = (0, import_node_path33.join)(rootDir, "src", node.id);
-    if (!(0, import_node_fs27.existsSync)(filePath)) continue;
-    const content = (0, import_node_fs27.readFileSync)(filePath, "utf-8");
+    const filePath = (0, import_node_path34.join)(rootDir, "src", node.id);
+    if (!(0, import_node_fs28.existsSync)(filePath)) continue;
+    const content = (0, import_node_fs28.readFileSync)(filePath, "utf-8");
     let m;
     allCapsRe.lastIndex = 0;
     while ((m = allCapsRe.exec(content)) !== null) {
@@ -35049,26 +35136,26 @@ function runAudit(rootDir, layer, check) {
 }
 
 // src/server/graph/core/projects.ts
-var import_node_path36 = require("node:path");
+var import_node_path37 = require("node:path");
 
 // src/server/lib/worktree.ts
-var import_node_path35 = require("node:path");
+var import_node_path36 = require("node:path");
 
 // src/server/orbit/registry.ts
-var import_node_fs28 = require("node:fs");
-var import_node_os5 = require("node:os");
-var import_node_path34 = require("node:path");
+var import_node_fs29 = require("node:fs");
+var import_node_os6 = require("node:os");
+var import_node_path35 = require("node:path");
 init_launch_kit_paths();
-var REGISTRY_DIR = (0, import_node_path34.join)((0, import_node_os5.homedir)(), LAUNCHSECURE_DIR, "orbit");
-var REGISTRY_PATH = (0, import_node_path34.join)(REGISTRY_DIR, "state.json");
-var LOCK_PATH = (0, import_node_path34.join)(REGISTRY_DIR, "state.json.lock");
+var REGISTRY_DIR = (0, import_node_path35.join)((0, import_node_os6.homedir)(), LAUNCHSECURE_DIR, "orbit");
+var REGISTRY_PATH = (0, import_node_path35.join)(REGISTRY_DIR, "state.json");
+var LOCK_PATH = (0, import_node_path35.join)(REGISTRY_DIR, "state.json.lock");
 function emptyRegistry() {
   return { version: 1, worktrees: {} };
 }
 function readRegistry() {
-  if (!(0, import_node_fs28.existsSync)(REGISTRY_PATH)) return emptyRegistry();
+  if (!(0, import_node_fs29.existsSync)(REGISTRY_PATH)) return emptyRegistry();
   try {
-    const parsed = JSON.parse((0, import_node_fs28.readFileSync)(REGISTRY_PATH, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs29.readFileSync)(REGISTRY_PATH, "utf-8"));
     if (parsed?.version === 1 && parsed.worktrees && typeof parsed.worktrees === "object") {
       return parsed;
     }
@@ -35098,7 +35185,7 @@ function resolveWorktreeRoot(slug, monorepoRoot) {
 function resolveWorktreeOrProjectRoot(args, monorepoRoot) {
   const projectRoot = typeof args.project_root === "string" ? args.project_root.trim() : "";
   if (projectRoot) {
-    return (0, import_node_path35.isAbsolute)(projectRoot) ? projectRoot : (0, import_node_path35.resolve)(monorepoRoot, projectRoot);
+    return (0, import_node_path36.isAbsolute)(projectRoot) ? projectRoot : (0, import_node_path36.resolve)(monorepoRoot, projectRoot);
   }
   const worktree = typeof args.worktree === "string" ? args.worktree.trim() : "";
   if (worktree) {
@@ -35117,7 +35204,7 @@ function listProjects(monorepoRoot) {
   return entries.map((p) => ({
     name: p.name,
     root: p.root,
-    absoluteRoot: (0, import_node_path36.resolve)(monorepoRoot, p.root)
+    absoluteRoot: (0, import_node_path37.resolve)(monorepoRoot, p.root)
   }));
 }
 function resolveProject(name, projects) {
@@ -36556,12 +36643,12 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui" || layer === "api") return (0, import_node_path38.join)(rootDir, "src", nodeId);
-  if (layer === "db") return (0, import_node_path38.join)(rootDir, "prisma", "schema.prisma");
-  const withSrc = (0, import_node_path38.join)(rootDir, "src", nodeId);
-  if ((0, import_node_fs30.existsSync)(withSrc)) return withSrc;
-  const direct = (0, import_node_path38.join)(rootDir, nodeId);
-  if ((0, import_node_fs30.existsSync)(direct)) return direct;
+  if (layer === "ui" || layer === "api") return (0, import_node_path39.join)(rootDir, "src", nodeId);
+  if (layer === "db") return (0, import_node_path39.join)(rootDir, "prisma", "schema.prisma");
+  const withSrc = (0, import_node_path39.join)(rootDir, "src", nodeId);
+  if ((0, import_node_fs31.existsSync)(withSrc)) return withSrc;
+  const direct = (0, import_node_path39.join)(rootDir, nodeId);
+  if ((0, import_node_fs31.existsSync)(direct)) return direct;
   return null;
 }
 function handleInspectNode(args) {
@@ -36829,11 +36916,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs30.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs31.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs30.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs31.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -37052,11 +37139,11 @@ function handleStartChartServer(args) {
     });
   }
   const entryPath = process.argv[1];
-  const logDir = (0, import_node_path38.join)((0, import_node_os6.homedir)(), LAUNCHSECURE_DIR);
-  (0, import_node_fs30.mkdirSync)(logDir, { recursive: true });
-  const logPath = (0, import_node_path38.join)(logDir, "launch-chart.log");
-  const out = (0, import_node_fs30.openSync)(logPath, "a");
-  const err2 = (0, import_node_fs30.openSync)(logPath, "a");
+  const logDir = (0, import_node_path39.join)((0, import_node_os7.homedir)(), LAUNCHSECURE_DIR);
+  (0, import_node_fs31.mkdirSync)(logDir, { recursive: true });
+  const logPath = (0, import_node_path39.join)(logDir, "launch-chart.log");
+  const out = (0, import_node_fs31.openSync)(logPath, "a");
+  const err2 = (0, import_node_fs31.openSync)(logPath, "a");
   const portArgs = args.port ? ["--port", String(args.port)] : [];
   const child = (0, import_node_child_process4.spawn)(process.execPath, [entryPath, "serve", ...portArgs], {
     detached: true,
@@ -37569,20 +37656,20 @@ function handleDetectProjectStack() {
       if (ref.type === "references_api") stats.references_api++;
     }
   }
-  const srcDir = (0, import_node_path38.join)(rootDir, "src");
-  if ((0, import_node_fs30.existsSync)(srcDir)) {
+  const srcDir = (0, import_node_path39.join)(rootDir, "src");
+  if ((0, import_node_fs31.existsSync)(srcDir)) {
     const scanDir = (dir) => {
-      if (!(0, import_node_fs30.existsSync)(dir)) return;
-      for (const entry of (0, import_node_fs30.readdirSync)(dir, { withFileTypes: true })) {
+      if (!(0, import_node_fs31.existsSync)(dir)) return;
+      for (const entry of (0, import_node_fs31.readdirSync)(dir, { withFileTypes: true })) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        const full = (0, import_node_path38.join)(dir, entry.name);
+        const full = (0, import_node_path39.join)(dir, entry.name);
         if (entry.isDirectory()) {
           scanDir(full);
           continue;
         }
-        if (![".ts", ".tsx"].includes((0, import_node_path38.extname)(entry.name))) continue;
+        if (![".ts", ".tsx"].includes((0, import_node_path39.extname)(entry.name))) continue;
         try {
-          const content = (0, import_node_fs30.readFileSync)(full, "utf-8");
+          const content = (0, import_node_fs31.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 {
@@ -37601,7 +37688,7 @@ function handleDetectProjectStack() {
     name: p.name,
     root: p.root,
     absolute_root: p.absoluteRoot,
-    has_graph: (0, import_node_fs30.existsSync)((0, import_node_path38.join)(p.absoluteRoot, LAUNCHSECURE_DIR, "graphs"))
+    has_graph: (0, import_node_fs31.existsSync)((0, import_node_path39.join)(p.absoluteRoot, LAUNCHSECURE_DIR, "graphs"))
   }));
   return okJson({
     languages,
@@ -38972,6 +39059,31 @@ if (!__isMcpMode) {
         });
         return;
       }
+      if (req.method === "POST" && url.pathname === "/api/radar/credentials") {
+        const chunks = [];
+        req.on("data", (c) => chunks.push(c));
+        req.on("end", () => {
+          let token;
+          try {
+            const body = JSON.parse(Buffer.concat(chunks).toString("utf-8") || "{}");
+            token = body.token;
+          } catch {
+          }
+          if (typeof token !== "string" || !token.trim()) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: "body must be {token: string}" }));
+            return;
+          }
+          radar.updateClaudeCredential(token).then((result) => {
+            res.writeHead(result.ok ? 200 : 400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+          }).catch((err2) => {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: err2.message }));
+          });
+        });
+        return;
+      }
       const sessionRenameMatch = url.pathname.match(/^\/api\/radar\/session\/([^/]+)$/);
       if (req.method === "PATCH" && sessionRenameMatch) {
         const pingId = sessionRenameMatch[1];