@launchsecure/launch-kit 0.0.39 → 0.0.41

package/dist/server/cli.js

@@ -1752,7 +1752,7 @@ var require_usage_reader = __commonJS({
       async readJsonlFile(filePath, cutoffTime) {
         const entries = [];
         const fileProcessedEntries = /* @__PURE__ */ new Set();
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const rl = readline.createInterface({
             input: createReadStream(filePath),
             crlfDelay: Infinity
@@ -1810,11 +1810,11 @@ var require_usage_reader = __commonJS({
             }
           });
           rl.on("close", () => {
-            resolve6(entries);
+            resolve7(entries);
           });
           rl.on("error", (error) => {
             console.error("Error reading file:", filePath, error);
-            resolve6(entries);
+            resolve7(entries);
           });
         });
       }
@@ -3623,7 +3623,7 @@ var require_src = __commonJS({
         if (session.active) throw new Error(`Agent already running in session ${sessionId}`);
         const { command, args = [], env = {} } = options;
         if (!command) throw new Error("startScriptInSession requires a command");
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           this.scriptBridge.startSession(sessionId, {
             command,
             args,
@@ -3645,7 +3645,7 @@ var require_src = __commonJS({
               session.lastActivity = /* @__PURE__ */ new Date();
               this.broadcastToSession(sessionId, { type: "script_stopped", sessionId });
               if (exitCode === 0) {
-                resolve6({ code: exitCode, signal });
+                resolve7({ code: exitCode, signal });
               } else {
                 reject(new Error(`Script exited with code ${exitCode}`));
               }
@@ -5567,9 +5567,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve7, reject) => {
             this.close((err2, data) => {
-              return err2 ? reject(err2) : resolve6(data);
+              return err2 ? reject(err2) : resolve7(data);
             });
           });
         }
@@ -5607,12 +5607,12 @@ var require_dispatcher_base = __commonJS({
           err2 = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve7, reject) => {
             this.destroy(err2, (err3, data) => {
               return err3 ? (
                 /* istanbul ignore next: should never error */
                 reject(err3)
-              ) : resolve6(data);
+              ) : resolve7(data);
             });
           });
         }
@@ -7879,8 +7879,8 @@ var require_util2 = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve6, reject) => {
-        res = resolve6;
+      const promise = new Promise((resolve7, reject) => {
+        res = resolve7;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -10021,12 +10021,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve6, reject) => {
+      const waitForDrain = () => new Promise((resolve7, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve6;
+          callback = resolve7;
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
@@ -10663,12 +10663,12 @@ var require_client_h2 = __commonJS({
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve6, reject) => {
+      const waitForDrain = () => new Promise((resolve7, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve6;
+          callback = resolve7;
         }
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -11146,16 +11146,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       async [kClose]() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve6;
+            this[kClosedResolve] = resolve7;
           } else {
-            resolve6(null);
+            resolve7(null);
           }
         });
       }
       async [kDestroy](err2) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request = requests[i];
@@ -11166,7 +11166,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve6(null);
+            resolve7(null);
           };
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err2, callback);
@@ -11217,7 +11217,7 @@ var require_client = __commonJS({
         });
       }
       try {
-        const socket = await new Promise((resolve6, reject) => {
+        const socket = await new Promise((resolve7, reject) => {
           client[kConnector]({
             host,
             hostname,
@@ -11229,7 +11229,7 @@ var require_client = __commonJS({
             if (err2) {
               reject(err2);
             } else {
-              resolve6(socket2);
+              resolve7(socket2);
             }
           });
         });
@@ -11565,8 +11565,8 @@ var require_pool_base = __commonJS({
         if (this[kQueue].isEmpty()) {
           await Promise.all(this[kClients].map((c) => c.close()));
         } else {
-          await new Promise((resolve6) => {
-            this[kClosedResolve] = resolve6;
+          await new Promise((resolve7) => {
+            this[kClosedResolve] = resolve7;
           });
         }
       }
@@ -12781,7 +12781,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return null;
         }
-        return await new Promise((resolve6, reject) => {
+        return await new Promise((resolve7, reject) => {
           if (this[kContentLength] > limit) {
             this.destroy(new AbortError());
           }
@@ -12794,7 +12794,7 @@ var require_readable = __commonJS({
             if (signal?.aborted) {
               reject(signal.reason ?? new AbortError());
             } else {
-              resolve6(null);
+              resolve7(null);
             }
           }).on("error", noop).on("data", function(chunk) {
             limit -= chunk.length;
@@ -12813,7 +12813,7 @@ var require_readable = __commonJS({
     }
     async function consume(stream, type) {
       assert(!stream[kConsume]);
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         if (isUnusable(stream)) {
           const rState = stream._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -12830,7 +12830,7 @@ var require_readable = __commonJS({
             stream[kConsume] = {
               type,
               stream,
-              resolve: resolve6,
+              resolve: resolve7,
               reject,
               length: 0,
               body: []
@@ -12900,18 +12900,18 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2) {
-      const { type, body, resolve: resolve6, stream, length } = consume2;
+      const { type, body, resolve: resolve7, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve6(chunksDecode(body, length));
+          resolve7(chunksDecode(body, length));
         } else if (type === "json") {
-          resolve6(JSON.parse(chunksDecode(body, length)));
+          resolve7(JSON.parse(chunksDecode(body, length)));
         } else if (type === "arrayBuffer") {
-          resolve6(chunksConcat(body, length).buffer);
+          resolve7(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve6(new Blob(body, { type: stream[kContentType] }));
+          resolve7(new Blob(body, { type: stream[kContentType] }));
         } else if (type === "bytes") {
-          resolve6(chunksConcat(body, length));
+          resolve7(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err2) {
@@ -13168,9 +13168,9 @@ var require_api_request = __commonJS({
     };
     function request(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           request.call(this, opts, (err2, data) => {
-            return err2 ? reject(err2) : resolve6(data);
+            return err2 ? reject(err2) : resolve7(data);
           });
         });
       }
@@ -13393,9 +13393,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           stream.call(this, opts, factory, (err2, data) => {
-            return err2 ? reject(err2) : resolve6(data);
+            return err2 ? reject(err2) : resolve7(data);
           });
         });
       }
@@ -13680,9 +13680,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           upgrade.call(this, opts, (err2, data) => {
-            return err2 ? reject(err2) : resolve6(data);
+            return err2 ? reject(err2) : resolve7(data);
           });
         });
       }
@@ -13774,9 +13774,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           connect.call(this, opts, (err2, data) => {
-            return err2 ? reject(err2) : resolve6(data);
+            return err2 ? reject(err2) : resolve7(data);
           });
         });
       }
@@ -17638,7 +17638,7 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        return new Promise((resolve6, reject) => agent.dispatch(
+        return new Promise((resolve7, reject) => agent.dispatch(
           {
             path: url.pathname + url.search,
             origin: url.origin,
@@ -17714,7 +17714,7 @@ var require_fetch = __commonJS({
                 }
               }
               const onError = this.onError.bind(this);
-              resolve6({
+              resolve7({
                 status,
                 statusText,
                 headersList,
@@ -17760,7 +17760,7 @@ var require_fetch = __commonJS({
               for (let i = 0; i < rawHeaders.length; i += 2) {
                 headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
               }
-              resolve6({
+              resolve7({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList,
@@ -21436,8 +21436,8 @@ var require_util8 = __commonJS({
       return true;
     }
     function delay(ms) {
-      return new Promise((resolve6) => {
-        setTimeout(resolve6, ms).unref();
+      return new Promise((resolve7) => {
+        setTimeout(resolve7, ms).unref();
       });
     }
     module2.exports = {
@@ -22628,7 +22628,7 @@ function resolveWorkerPath() {
   );
 }
 function runParseInWorker(req) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let workerPath;
     try {
       workerPath = resolveWorkerPath();
@@ -22647,7 +22647,7 @@ function runParseInWorker(req) {
     };
     worker.on("message", (reply) => {
       if (reply.ok) {
-        finish(() => resolve6({ results: reply.results, failedFiles: reply.failedFiles }));
+        finish(() => resolve7({ results: reply.results, failedFiles: reply.failedFiles }));
       } else {
         const err2 = new Error(reply.error.message);
         err2.name = reply.error.name;
@@ -22741,6 +22741,328 @@ var init_effects_index = __esm({
   }
 });
 
+// src/server/graph/core/context/types.ts
+function higherConfidence(a, b) {
+  return CONFIDENCE_RANK[a] >= CONFIDENCE_RANK[b] ? a : b;
+}
+function stateId(token) {
+  return `state:${token}`;
+}
+function actionId(key) {
+  return `action:${key}`;
+}
+function stateNode(token, label) {
+  return { id: stateId(token), type: CONTEXT_NODE_STATE, name: token, label };
+}
+function actionNode(key, name, meta = {}) {
+  return { id: actionId(key), type: CONTEXT_NODE_ACTION, name, ...meta };
+}
+function contextEdge(fromActionId, toStateId, type, confidence, origin) {
+  return { source: fromActionId, target: toStateId, type, label: `${type} (${origin})`, confidence, origin };
+}
+var CONTEXT_NODE_ACTION, CONTEXT_NODE_STATE, CONFIDENCE_RANK;
+var init_types = __esm({
+  "src/server/graph/core/context/types.ts"() {
+    "use strict";
+    CONTEXT_NODE_ACTION = "action";
+    CONTEXT_NODE_STATE = "state";
+    CONFIDENCE_RANK = { low: 0, medium: 1, high: 2 };
+  }
+});
+
+// src/server/graph/core/context/providers/nextjs-prisma.ts
+function isPublic(auth) {
+  if (!auth || auth.length === 0) return true;
+  return auth.every((a) => a === "public");
+}
+function notFoundEntity(consequence) {
+  if (!consequence) return null;
+  const m = consequence.match(/notFound\(\s*['"]([A-Za-z0-9_]+)['"]/);
+  return m ? m[1] : null;
+}
+var PRODUCING_METHODS, nextjsPrismaContextProvider;
+var init_nextjs_prisma = __esm({
+  "src/server/graph/core/context/providers/nextjs-prisma.ts"() {
+    "use strict";
+    init_types();
+    PRODUCING_METHODS = /* @__PURE__ */ new Set(["create", "createMany", "upsert"]);
+    nextjsPrismaContextProvider = {
+      id: "nextjs-prisma",
+      detect(layerOutputs) {
+        const api = layerOutputs["api"];
+        return !!api && (api.nodes ?? []).some((n) => n.type === "endpoint");
+      },
+      derive(layerOutputs) {
+        const api = layerOutputs["api"];
+        const states = /* @__PURE__ */ new Map();
+        const actions = [];
+        const edges = [];
+        const seenEdge = /* @__PURE__ */ new Set();
+        const ensureState = (token, label) => {
+          const id = stateId(token);
+          if (!states.has(id)) states.set(id, stateNode(token, label));
+          return id;
+        };
+        const addEdge = (from, to, type, confidence, origin) => {
+          const key = `${from}|${type}|${to}`;
+          if (seenEdge.has(key)) return;
+          seenEdge.add(key);
+          edges.push(contextEdge(from, to, type, confidence, origin));
+        };
+        const endpoints = (api?.nodes ?? []).filter((n) => n.type === "endpoint");
+        for (const ep of endpoints) {
+          const aId = actionId(ep.id);
+          actions.push(actionNode(ep.id, ep.name, { methods: ep.methods ?? [], endpoint: ep.id }));
+          if (!isPublic(ep.auth)) {
+            addEdge(aId, ensureState("session", "Authenticated session"), "requires", "high", "auth-wrapper");
+          }
+          for (const op of ep.db_operations ?? []) {
+            const [model, method] = op.split(".");
+            if (!model || !PRODUCING_METHODS.has(method ?? "")) continue;
+            addEdge(aId, ensureState(model, `${model} record exists`), "produces", "medium", `db:${op}`);
+          }
+          for (const cond of ep.conditions ?? []) {
+            const entity = notFoundEntity(cond.consequence);
+            if (!entity) continue;
+            const token = entity.toLowerCase();
+            addEdge(aId, ensureState(token, `${token} record exists`), "requires", "low", "guard:notFound");
+          }
+        }
+        return { nodes: [...actions, ...states.values()], edges };
+      }
+    };
+  }
+});
+
+// src/server/graph/core/context/overlay.ts
+function overlayPath(rootDir) {
+  return (0, import_node_path12.join)(rootDir, OVERLAY_FILE);
+}
+function loadOverlay(rootDir) {
+  const path13 = overlayPath(rootDir);
+  if (!(0, import_node_fs10.existsSync)(path13)) return null;
+  try {
+    return JSON.parse((0, import_node_fs10.readFileSync)(path13, "utf-8"));
+  } catch (e) {
+    process.stderr.write(`[launch-chart] failed to parse ${OVERLAY_FILE}: ${e.message}
+`);
+    return null;
+  }
+}
+function applyOverlayRejections(edges, rootDir) {
+  const overlay = loadOverlay(rootDir);
+  const rejects = overlay?.reject ?? [];
+  if (rejects.length === 0) return edges;
+  const rejectKeys = new Set(
+    rejects.map((r) => `${actionId(r.action)}|${r.type}|${stateId(r.state)}`)
+  );
+  return edges.filter((e) => !rejectKeys.has(`${e.source}|${e.type}|${e.target}`));
+}
+var import_node_fs10, import_node_path12, 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");
+    init_types();
+    OVERLAY_FILE = ".launchchart.context.json";
+    overlayProvider = {
+      id: "overlay",
+      detect(_layerOutputs, rootDir) {
+        return (0, import_node_fs10.existsSync)(overlayPath(rootDir));
+      },
+      derive(_layerOutputs, rootDir) {
+        const overlay = loadOverlay(rootDir);
+        if (!overlay) return { nodes: [], edges: [] };
+        const nodes = /* @__PURE__ */ new Map();
+        const edges = [];
+        const seenEdge = /* @__PURE__ */ new Set();
+        const ensureState = (token, label) => {
+          const id = stateId(token);
+          if (!nodes.has(id)) nodes.set(id, stateNode(token, label ?? `${token} (overlay)`));
+          return id;
+        };
+        const ensureAction = (key, name) => {
+          const id = actionId(key);
+          if (!nodes.has(id)) nodes.set(id, actionNode(key, name ?? key, { source: "overlay" }));
+          return id;
+        };
+        for (const s of overlay.states ?? []) ensureState(s.token, s.label);
+        for (const a of overlay.actions ?? []) ensureAction(a.id, a.name);
+        for (const e of overlay.edges ?? []) {
+          const aId = ensureAction(e.action);
+          const link = (token, type) => {
+            const sId = ensureState(token);
+            const key = `${aId}|${type}|${sId}`;
+            if (seenEdge.has(key)) return;
+            seenEdge.add(key);
+            edges.push(contextEdge(aId, sId, type, "high", "overlay"));
+          };
+          for (const token of e.requires ?? []) link(token, "requires");
+          for (const token of e.produces ?? []) link(token, "produces");
+        }
+        return { nodes: [...nodes.values()], edges };
+      }
+    };
+  }
+});
+
+// src/server/graph/core/context/registry.ts
+function registerBuiltins2(registry, disabled) {
+  const builtins = [nextjsPrismaContextProvider, overlayProvider];
+  for (const provider of builtins) {
+    if (disabled.has(provider.id)) continue;
+    registry.register(provider);
+  }
+}
+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 mod = require(absPath);
+      const provider = "default" in mod ? mod.default : mod;
+      if (disabled.has(provider.id)) continue;
+      registry.register(provider);
+    } catch (err2) {
+      process.stderr.write(`[launch-chart] failed to load custom context provider from ${entry.path}: ${err2}
+`);
+    }
+  }
+}
+function createContextProviderRegistry(config, rootDir) {
+  const registry = new ContextProviderRegistry();
+  const disabled = new Set(config.context?.disabled ?? []);
+  registerBuiltins2(registry, disabled);
+  loadCustomProviders(registry, config, rootDir, disabled);
+  return registry;
+}
+var import_node_path13, ContextProviderRegistry;
+var init_registry = __esm({
+  "src/server/graph/core/context/registry.ts"() {
+    "use strict";
+    import_node_path13 = require("node:path");
+    init_nextjs_prisma();
+    init_overlay();
+    ContextProviderRegistry = class {
+      constructor() {
+        this.providers = [];
+        this.ids = /* @__PURE__ */ new Set();
+      }
+      register(provider) {
+        if (this.ids.has(provider.id)) {
+          throw new Error(`Duplicate context provider id: ${provider.id}`);
+        }
+        this.ids.add(provider.id);
+        this.providers.push(provider);
+      }
+      getAll() {
+        return [...this.providers];
+      }
+    };
+  }
+});
+
+// src/server/graph/core/context-map.ts
+function buildContextMap(layerOutputs, rootDir) {
+  const generated = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const config = loadConfig(rootDir);
+  const registry = createContextProviderRegistry(config, rootDir);
+  const nodesById = /* @__PURE__ */ new Map();
+  const edgesByKey = /* @__PURE__ */ new Map();
+  const providerStats = {};
+  const usedProviders = [];
+  for (const provider of registry.getAll()) {
+    let detected = false;
+    try {
+      detected = provider.detect(layerOutputs, rootDir);
+    } catch (e) {
+      process.stderr.write(`[launch-chart] context provider "${provider.id}" detect failed: ${e.message}
+`);
+      continue;
+    }
+    if (!detected) continue;
+    let contribution;
+    try {
+      contribution = provider.derive(layerOutputs, rootDir);
+    } catch (e) {
+      process.stderr.write(`[launch-chart] context provider "${provider.id}" derive failed: ${e.message}
+`);
+      continue;
+    }
+    usedProviders.push(provider.id);
+    providerStats[provider.id] = { nodes: contribution.nodes.length, edges: contribution.edges.length };
+    for (const node of contribution.nodes) {
+      if (!nodesById.has(node.id)) nodesById.set(node.id, node);
+    }
+    for (const edge of contribution.edges) {
+      const key = `${edge.source}|${edge.type}|${edge.target}`;
+      const existing = edgesByKey.get(key);
+      const edgeConf = edge.confidence ?? "low";
+      if (!existing) {
+        edgesByKey.set(key, { ...edge, providers: [provider.id] });
+      } else {
+        const existingConf = existing.confidence ?? "low";
+        existing.confidence = higherConfidence(existingConf, edgeConf);
+        const provs = existing.providers ?? [];
+        if (!provs.includes(provider.id)) provs.push(provider.id);
+        existing.providers = provs;
+      }
+    }
+  }
+  const merged = [...edgesByKey.values()];
+  const edges = applyOverlayRejections(merged, rootDir);
+  const rejectedCount = merged.length - edges.length;
+  const flagged = edges.map((e) => ({
+    source: e.source,
+    target: e.target,
+    type: e.type,
+    label: e.label ?? `${e.type}`,
+    confidence: e.confidence ?? "low"
+  }));
+  const nodes = [...nodesById.values()];
+  const stateCount = nodes.filter((n) => n.type === CONTEXT_NODE_STATE).length;
+  return {
+    metadata: {
+      generated,
+      scope: "derived",
+      layer: "context",
+      source: "context-map-builder",
+      derived: true,
+      providers: usedProviders,
+      provider_stats: providerStats,
+      action_count: nodes.length - stateCount,
+      state_count: stateCount,
+      candidate_edge_count: edges.length,
+      rejected_edge_count: rejectedCount,
+      note: "Edges are candidates (see flagged_edges + confidence) from the context providers. Promote via the curation overlay."
+    },
+    nodes,
+    edges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [],
+    flagged_edges: flagged
+  };
+}
+function writeContextMap(rootDir, output) {
+  const path13 = (0, import_node_path14.join)(rootDir, LAUNCHSECURE_DIR, "graphs", "context.json");
+  atomicWriteFileSync(path13, JSON.stringify(output, null, 2) + "\n");
+  return path13;
+}
+var import_node_path14;
+var init_context_map = __esm({
+  "src/server/graph/core/context-map.ts"() {
+    "use strict";
+    init_atomic_write();
+    import_node_path14 = require("node:path");
+    init_launch_kit_paths();
+    init_config();
+    init_registry();
+    init_overlay();
+    init_types();
+  }
+});
+
 // src/server/graph/core/freshness.ts
 function exactFilenameRegex(name) {
   return new RegExp(`^${name.replace(/\./g, "\\.")}$`);
@@ -22756,12 +23078,12 @@ function getFreshnessTracker(rootDir) {
   }
   return t;
 }
-var import_node_fs10, import_node_path12, SCHEMA_VERSION, MAX_PATCHED_FILES_TRACKED, DRIFTING_PATCH_THRESHOLD, HARD_ESCALATION_PATTERNS, FreshnessTracker, trackers;
+var import_node_fs11, import_node_path15, 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_fs10 = require("node:fs");
-    import_node_path12 = require("node:path");
+    import_node_fs11 = require("node:fs");
+    import_node_path15 = require("node:path");
     init_launch_kit_paths();
     init_atomic_write();
     SCHEMA_VERSION = 1;
@@ -22778,7 +23100,7 @@ var init_freshness = __esm({
     FreshnessTracker = class {
       constructor(rootDir) {
         this.dirty = false;
-        this.filePath = (0, import_node_path12.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".freshness.json");
+        this.filePath = (0, import_node_path15.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".freshness.json");
         this.snapshot = this.load() ?? {
           state: "fresh",
           lastFullRegenAt: null,
@@ -22865,9 +23187,9 @@ var init_freshness = __esm({
         }
       }
       load() {
-        if (!(0, import_node_fs10.existsSync)(this.filePath)) return null;
+        if (!(0, import_node_fs11.existsSync)(this.filePath)) return null;
         try {
-          const parsed = JSON.parse((0, import_node_fs10.readFileSync)(this.filePath, "utf-8"));
+          const parsed = JSON.parse((0, import_node_fs11.readFileSync)(this.filePath, "utf-8"));
           if (parsed.schemaVersion !== SCHEMA_VERSION) return null;
           return {
             state: parsed.state,
@@ -22889,22 +23211,22 @@ var init_freshness = __esm({
 
 // src/server/graph/index.ts
 function getAvailableLayers(rootDir) {
-  const dir = (0, import_node_path13.join)(rootDir, GRAPHS_DIR2);
-  if (!(0, import_node_fs11.existsSync)(dir)) return [];
-  return (0, import_node_fs11.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_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", ""));
 }
 function graphsDir(rootDir) {
-  return (0, import_node_path13.join)(rootDir, GRAPHS_DIR2);
+  return (0, import_node_path16.join)(rootDir, GRAPHS_DIR2);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path13.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path16.join)(graphsDir(rootDir), `${layer}.json`);
 }
 function tagsFilePath2(rootDir) {
-  return (0, import_node_path13.join)(graphsDir(rootDir), "tags.json");
+  return (0, import_node_path16.join)(graphsDir(rootDir), "tags.json");
 }
 function getMtimeMs(filePath) {
-  if (!(0, import_node_fs11.existsSync)(filePath)) return 0;
-  return (0, import_node_fs11.statSync)(filePath).mtimeMs;
+  if (!(0, import_node_fs12.existsSync)(filePath)) return 0;
+  return (0, import_node_fs12.statSync)(filePath).mtimeMs;
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
@@ -22943,20 +23265,20 @@ function applyTags(graph, layer, rootDir) {
 }
 function readGraphRaw(rootDir, layer) {
   const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs11.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs11.statSync)(filePath);
+  if (!(0, import_node_fs12.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs12.statSync)(filePath);
   const cached = graphCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.graph;
   }
-  const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs12.readFileSync)(filePath, "utf-8");
   const graph = JSON.parse(content);
   graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
   return graph;
 }
 function readGraph(rootDir, layer) {
   const rawFilePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs11.existsSync)(rawFilePath)) return null;
+  if (!(0, import_node_fs12.existsSync)(rawFilePath)) return null;
   const rawMtime = getMtimeMs(rawFilePath);
   const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
   const cacheKey = `${rootDir}:${layer}`;
@@ -22980,7 +23302,7 @@ function readAllGraphs(rootDir) {
 }
 async function generateGraph(rootDir, layer) {
   const dir = graphsDir(rootDir);
-  (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs12.mkdirSync)(dir, { recursive: true });
   const { results, failedFiles } = await runParseInWorker({ rootDir, layer });
   for (const result of results) {
     const filePath = graphFilePath(rootDir, result.layer);
@@ -22991,13 +23313,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_fs11.readdirSync)(dir)) {
-        if (!f.endsWith(".json") || f === "tags.json" || f === "effects-index.json") continue;
+      for (const f of (0, import_node_fs12.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_path13.join)(dir, f);
+        const orphan = (0, import_node_path16.join)(dir, f);
         try {
-          (0, import_node_fs11.unlinkSync)(orphan);
+          (0, import_node_fs12.unlinkSync)(orphan);
           invalidateCache(orphan);
           invalidateTaggedCache(rootDir, layerName);
           process.stderr.write(`[launch-chart] removed orphan layer file: ${f} (no parser produced ${layerName} this run)
@@ -23008,22 +23330,31 @@ async function generateGraph(rootDir, layer) {
     } catch {
     }
   }
-  try {
-    const allLayers = {};
-    for (const r of results) allLayers[r.layer] = r.output;
-    if (layer) {
-      for (const f of (0, import_node_fs11.readdirSync)(dir)) {
-        if (!f.endsWith(".json") || f === "tags.json" || f === "effects-index.json") continue;
-        const layerName = f.replace(/\.json$/, "");
-        if (allLayers[layerName]) continue;
-        const existing = readGraphRaw(rootDir, layerName);
-        if (existing) allLayers[layerName] = existing;
-      }
+  const allLayers = {};
+  for (const r of results) allLayers[r.layer] = r.output;
+  if (layer) {
+    for (const f of (0, import_node_fs12.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;
+      const existing = readGraphRaw(rootDir, layerName);
+      if (existing) allLayers[layerName] = existing;
     }
+  }
+  try {
     const idx = buildEffectsIndex(allLayers);
     writeEffectsIndex(rootDir, idx);
   } catch (e) {
     process.stderr.write(`[launch-chart] effects-index build failed: ${e.message}
+`);
+  }
+  try {
+    const ctx = buildContextMap(allLayers, rootDir);
+    const ctxPath = writeContextMap(rootDir, ctx);
+    invalidateCache(ctxPath);
+    invalidateTaggedCache(rootDir, "context");
+  } catch (e) {
+    process.stderr.write(`[launch-chart] context-map build failed: ${e.message}
 `);
   }
   try {
@@ -23040,25 +23371,26 @@ async function generateGraph(rootDir, layer) {
   return results;
 }
 function readEffectsIndex(rootDir) {
-  const path13 = (0, import_node_path13.join)(rootDir, GRAPHS_DIR2, "effects-index.json");
-  if (!(0, import_node_fs11.existsSync)(path13)) return null;
+  const path13 = (0, import_node_path16.join)(rootDir, GRAPHS_DIR2, "effects-index.json");
+  if (!(0, import_node_fs12.existsSync)(path13)) return null;
   try {
-    return JSON.parse((0, import_node_fs11.readFileSync)(path13, "utf-8"));
+    return JSON.parse((0, import_node_fs12.readFileSync)(path13, "utf-8"));
   } catch {
     return null;
   }
 }
-var import_node_fs11, import_node_path13, GRAPHS_DIR2, NON_LAYER_GRAPH_FILES, graphCache, taggedCache;
+var import_node_fs12, import_node_path16, GRAPHS_DIR2, NON_LAYER_GRAPH_FILES, graphCache, taggedCache;
 var init_graph = __esm({
   "src/server/graph/index.ts"() {
     "use strict";
-    import_node_fs11 = require("node:fs");
-    import_node_path13 = require("node:path");
+    import_node_fs12 = require("node:fs");
+    import_node_path16 = require("node:path");
     init_config();
     init_tagger_registry();
     init_tag_store();
     init_parse_worker_host();
     init_effects_index();
+    init_context_map();
     init_atomic_write();
     init_freshness();
     init_tag_store();
@@ -23136,8 +23468,8 @@ function getQuery(name) {
   ensureInit();
   const cached = queryCache.get(name);
   if (cached) return cached;
-  const scmPath = (0, import_node_path17.join)(queriesDir, `${name}.scm`);
-  const scm = (0, import_node_fs15.readFileSync)(scmPath, "utf-8");
+  const scmPath = (0, import_node_path22.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs17.readFileSync)(scmPath, "utf-8");
   const query = tsxLanguage.query(scm);
   queryCache.set(name, query);
   return query;
@@ -23157,13 +23489,13 @@ function parseSource(absPath) {
   ensureInit();
   let content;
   try {
-    const stat = (0, import_node_fs15.statSync)(absPath);
+    const stat = (0, import_node_fs17.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_fs15.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs17.readFileSync)(absPath, "utf-8");
   } catch (e) {
     process.stderr.write(`[lc-extractor] read failed for ${absPath}: ${e instanceof Error ? e.message : String(e)}
 `);
@@ -24197,18 +24529,18 @@ function collectUiLabels(root) {
   visit(root);
   return out;
 }
-var import_node_fs15, import_node_path17, 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_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 init_ts_extractor = __esm({
   "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
-    import_node_fs15 = require("node:fs");
-    import_node_path17 = require("node:path");
+    import_node_fs17 = require("node:fs");
+    import_node_path22 = require("node:path");
     init_parse_failure_cache();
     initialized = false;
     queriesDir = (() => {
-      const srcPath = (0, import_node_path17.join)((0, import_node_path17.dirname)(__filename), "..", "queries");
+      const srcPath = (0, import_node_path22.join)((0, import_node_path22.dirname)(__filename), "..", "queries");
       if (require("fs").existsSync(srcPath)) return srcPath;
-      return (0, import_node_path17.join)((0, import_node_path17.dirname)(__filename), "graph", "queries");
+      return (0, import_node_path22.join)((0, import_node_path22.dirname)(__filename), "graph", "queries");
     })();
     queryCache = /* @__PURE__ */ new Map();
     MAX_PARSEABLE_BYTES = 2 * 1024 * 1024;
@@ -24348,7 +24680,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_path32.sep)) {
+  for (const part of rel.split(import_node_path37.sep)) {
     if (IGNORE_SEGMENTS.has(part)) return true;
   }
   return false;
@@ -24390,7 +24722,7 @@ function startGraphWatcher(rootDir, opts = {}) {
       regenerating = false;
     }
   }
-  const watcher = (0, import_node_fs27.watch)(rootDir, { recursive: true }, (event, filename) => {
+  const watcher = (0, import_node_fs29.watch)(rootDir, { recursive: true }, (event, filename) => {
     if (!filename) return;
     const rel = filename.toString();
     if (process.env.LAUNCH_CHART_WATCH_TRACE === "1") {
@@ -24423,12 +24755,12 @@ function startGraphWatcher(rootDir, opts = {}) {
     freshness: () => getFreshnessTracker(rootDir).get()
   };
 }
-var import_node_fs27, import_node_path32, IGNORE_SEGMENTS, TRIGGER_EXTENSIONS, GRAPHS_RELATIVE;
+var import_node_fs29, import_node_path37, IGNORE_SEGMENTS, TRIGGER_EXTENSIONS, GRAPHS_RELATIVE;
 var init_watcher = __esm({
   "src/server/graph/core/watcher.ts"() {
     "use strict";
-    import_node_fs27 = require("node:fs");
-    import_node_path32 = require("node:path");
+    import_node_fs29 = require("node:fs");
+    import_node_path37 = require("node:path");
     init_launch_kit_paths();
     init_graph();
     init_freshness();
@@ -24457,7 +24789,7 @@ var init_watcher = __esm({
       ".prisma",
       ".sql"
     ]);
-    GRAPHS_RELATIVE = (0, import_node_path32.join)(LAUNCHSECURE_DIR, "graphs");
+    GRAPHS_RELATIVE = (0, import_node_path37.join)(LAUNCHSECURE_DIR, "graphs");
   }
 });
 
@@ -26135,7 +26467,7 @@ var PostImplLaunchExecutor = class {
     return 3001;
   }
   startDevServer(port, databaseUrl) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const env = { ...process.env, PORT: String(port), ...databaseUrl ? { DATABASE_URL: databaseUrl } : {} };
       this.devProcess = (0, import_child_process3.spawn)("npm", ["run", "dev"], {
         cwd: this.workingDir,
@@ -26147,7 +26479,7 @@ var PostImplLaunchExecutor = class {
       const timeout = setTimeout(() => {
         if (!resolved) {
           resolved = true;
-          this.healthCheck(port).then(resolve6);
+          this.healthCheck(port).then(resolve7);
         }
       }, 15e3);
       const onData = (data) => {
@@ -26156,7 +26488,7 @@ var PostImplLaunchExecutor = class {
           if (!resolved) {
             resolved = true;
             clearTimeout(timeout);
-            resolve6(true);
+            resolve7(true);
           }
         }
       };
@@ -26167,7 +26499,7 @@ var PostImplLaunchExecutor = class {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeout);
-          resolve6(false);
+          resolve7(false);
         }
       });
       this.devProcess.unref();
@@ -27564,7 +27896,7 @@ var ProjectMcpClient = class {
     this.initialized = true;
   }
   send(body) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const headers = {
         ...this.headers,
         "Content-Length": String(Buffer.byteLength(body))
@@ -27589,7 +27921,7 @@ var ProjectMcpClient = class {
               return;
             }
             const sid = res.headers["mcp-session-id"];
-            resolve6({ body: text, sessionId: typeof sid === "string" ? sid : void 0 });
+            resolve7({ body: text, sessionId: typeof sid === "string" ? sid : void 0 });
           });
         }
       );
@@ -28688,16 +29020,16 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
     const tun = this.tunnel;
     this.tunnel = null;
     if (!tun) return;
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       tun.once("exit", () => {
         this.emit("stopped");
-        resolve6();
+        resolve7();
       });
       try {
         tun.stop();
       } catch {
       }
-      setTimeout(() => resolve6(), 6e3);
+      setTimeout(() => resolve7(), 6e3);
     });
   }
   spawnOnce() {
@@ -29439,38 +29771,249 @@ function streamTranscript(opts) {
 }
 
 // src/server/graph-mcp.ts
-var import_node_fs28 = require("node:fs");
-var import_node_path33 = require("node:path");
+var import_node_fs30 = require("node:fs");
+var import_node_path38 = require("node:path");
 var import_node_child_process3 = require("node:child_process");
 var import_node_os6 = require("node:os");
 init_launch_kit_paths();
 init_graph();
 
+// src/server/graph/core/context/snippet.ts
+function toExportName(name) {
+  const words = name.replace(/^action:/, "").replace(/^state:/, "").split(/[^A-Za-z0-9]+/).filter(Boolean).filter((w) => w.toLowerCase() !== "api");
+  if (words.length === 0) return "snippet";
+  const camel = words.map((w, i) => i === 0 ? w.charAt(0).toLowerCase() + w.slice(1) : w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  return /^[0-9]/.test(camel) ? `s${camel}` : camel;
+}
+function scaffoldSnippet(input) {
+  const exportName = toExportName(input.name || input.nodeId);
+  const arr = (xs) => `[${xs.map((x) => `'${x}'`).join(", ")}]`;
+  const code = `import { type Page } from '@playwright/test';
+
+/**
+ * Snippet: ${input.name}
+ * Scaffolded by launch-chart \`scaffold_snippet\` \u2014 conforms to the Snippet shape.
+ * requires/produces are derived from the context graph. TODO(you):
+ *   1. fill \`params\` from the endpoint's request/validation schema;
+ *   2. implement \`run()\` with real Playwright steps (navigate, fill, click, assert).
+ */
+export const ${exportName} = {
+  id: '${input.nodeId}',
+  requires: ${arr(input.requires)},
+  produces: ${arr(input.produces)},
+  params: [], // TODO: e.g. ['name', 'color'] \u2014 from the endpoint schema
+  async run(page: Page, params: Record<string, unknown>) {
+    // TODO: implement with Playwright.
+    // e.g. await page.goto('/...'); await page.fill('#...', params.x); await page.click('text=Save');
+  },
+};
+`;
+  return { exportName, code };
+}
+
+// src/server/graph/core/context/snippet-registry.ts
+var import_node_fs13 = require("node:fs");
+var import_node_path17 = require("node:path");
+var DEFAULT_SNIPPETS_DIR = "tests/snippets";
+function parseStringArray(src, key) {
+  const m = src.match(new RegExp(`${key}\\s*:\\s*\\[([^\\]]*)\\]`));
+  if (!m) return [];
+  return [...m[1].matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]);
+}
+function parseSnippetFile(content, file) {
+  const idM = content.match(/\bid\s*:\s*['"]([^'"]+)['"]/);
+  if (!idM) return null;
+  const exportM = content.match(/export\s+const\s+(\w+)/);
+  return {
+    id: idM[1],
+    exportName: exportM ? exportM[1] : "default",
+    file,
+    requires: parseStringArray(content, "requires"),
+    produces: parseStringArray(content, "produces"),
+    params: parseStringArray(content, "params")
+  };
+}
+function loadSnippetIndex(rootDir, snippetsDir = DEFAULT_SNIPPETS_DIR) {
+  const dir = (0, import_node_path17.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 (!f.endsWith(".ts") && !f.endsWith(".tsx")) continue;
+    const full = (0, import_node_path17.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 (entry) index.set(entry.id, entry);
+    } catch {
+    }
+  }
+  return index;
+}
+
+// src/server/graph/core/context/test-plan.ts
+var stripState = (s) => s.replace(/^state:/, "");
+function buildTestPlan(graph, targetId, snippets) {
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) nodesById.set(n.id, n);
+  const requiresOf = /* @__PURE__ */ new Map();
+  const producesOf = /* @__PURE__ */ new Map();
+  const producersOf = /* @__PURE__ */ new Map();
+  for (const e of graph.edges) {
+    if (e.type === "requires") {
+      (requiresOf.get(e.source) ?? requiresOf.set(e.source, /* @__PURE__ */ new Set()).get(e.source)).add(e.target);
+    } else if (e.type === "produces") {
+      (producesOf.get(e.source) ?? producesOf.set(e.source, /* @__PURE__ */ new Set()).get(e.source)).add(e.target);
+      (producersOf.get(e.target) ?? producersOf.set(e.target, /* @__PURE__ */ new Set()).get(e.target)).add(e.source);
+    }
+  }
+  const pickProducer = (producers) => {
+    const withSnippet = producers.filter((p) => snippets.has(p)).sort();
+    return withSnippet.length ? withSnippet[0] : [...producers].sort()[0];
+  };
+  const order = [];
+  const done = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const gaps = [];
+  const allRequired = /* @__PURE__ */ new Set();
+  const visit = (actionId2) => {
+    if (done.has(actionId2)) return;
+    if (visiting.has(actionId2)) {
+      gaps.push({ type: "cycle", action: actionId2, detail: `dependency cycle through ${actionId2}` });
+      return;
+    }
+    visiting.add(actionId2);
+    for (const state of requiresOf.get(actionId2) ?? []) {
+      allRequired.add(state);
+      const producers = [...producersOf.get(state) ?? []];
+      if (producers.length === 0) {
+        gaps.push({
+          type: "no_producer",
+          state: stripState(state),
+          action: actionId2,
+          detail: `${actionId2} requires "${stripState(state)}" but no action produces it`
+        });
+        continue;
+      }
+      visit(pickProducer(producers));
+    }
+    visiting.delete(actionId2);
+    done.add(actionId2);
+    order.push(actionId2);
+  };
+  visit(targetId);
+  const steps = order.map((actionId2) => {
+    const node = nodesById.get(actionId2);
+    const entry = snippets.get(actionId2) ?? null;
+    if (!entry) {
+      gaps.push({
+        type: "no_snippet",
+        action: actionId2,
+        detail: `no snippet bound to ${actionId2} \u2014 scaffold one with scaffold_snippet`
+      });
+    }
+    const satisfies = [...producesOf.get(actionId2) ?? []].filter((s) => allRequired.has(s)).map(stripState).sort();
+    return {
+      action: actionId2,
+      name: String(node?.name ?? actionId2),
+      satisfies,
+      snippet: entry ? { id: entry.id, exportName: entry.exportName, file: entry.file, params: entry.params } : null
+    };
+  });
+  return { target: targetId, steps, gaps, runnable: gaps.length === 0 };
+}
+
+// src/server/graph/core/context/spec-gen.ts
+var import_node_path18 = require("node:path");
+function toEnvRef(name) {
+  return `process.env.${name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase()}`;
+}
+function classify(name) {
+  const n = name.toLowerCase();
+  if (/pass|secret|token|credential|apikey|api_key|_key$|^key$/.test(n)) return { kind: "secret" };
+  if (/email|slug|(^|_)id$|uuid|userid|orgid|projectid/.test(n)) return { kind: "real" };
+  if (/desc|summary|body|message|content|note/.test(n)) return { kind: "faker", faker: "faker.lorem.sentence()" };
+  if (/colou?r/.test(n)) return { kind: "faker", faker: "faker.color.rgb({ format: 'hex' })" };
+  if (/icon/.test(n)) return { kind: "faker", faker: "faker.helpers.arrayElement(['rocket','bug','star','flag','zap','heart'])" };
+  if (/name|title|label/.test(n)) return { kind: "faker", faker: "faker.word.noun()" };
+  if (/url|link|href/.test(n)) return { kind: "faker", faker: "faker.internet.url()" };
+  if (/count|qty|quantity|amount|number|price/.test(n)) return { kind: "faker", faker: "String(faker.number.int({ min: 1, max: 100 }))" };
+  return { kind: "faker", faker: "faker.lorem.word()" };
+}
+function relImport(specDir, file) {
+  let r = (0, import_node_path18.relative)(specDir, file).replace(/\.tsx?$/, "");
+  if (!r.startsWith(".")) r = `./${r}`;
+  return r;
+}
+function generateSpec(plan, opts = {}) {
+  const specDir = opts.specDir ?? "tests/generated";
+  const fixtures = opts.fixtures ?? {};
+  const missing = /* @__PURE__ */ new Set();
+  let usesFaker = false;
+  const bound = plan.steps.filter((s) => s.snippet);
+  const unbound = plan.steps.filter((s) => !s.snippet);
+  const importLines = /* @__PURE__ */ new Set();
+  for (const s of bound) {
+    importLines.add(`import { ${s.snippet.exportName} } from '${relImport(specDir, s.snippet.file)}';`);
+  }
+  const callLines = bound.map((s) => {
+    const params = s.snippet.params.map((p) => {
+      if (Object.prototype.hasOwnProperty.call(fixtures, p)) {
+        return `    ${p}: ${JSON.stringify(fixtures[p])},`;
+      }
+      const c = classify(p);
+      if (c.kind === "secret") return `    ${p}: ${toEnvRef(p)},`;
+      if (c.kind === "faker") {
+        usesFaker = true;
+        return `    ${p}: ${c.faker},`;
+      }
+      missing.add(p);
+      return `    ${p}: undefined, // TODO: real value (seeded ${p})`;
+    });
+    const block = params.length ? `{
+${params.join("\n")}
+  }` : "{}";
+    return `  await ${s.snippet.exportName}.run(page, ${block});`;
+  });
+  const warnings = unbound.map(
+    (s) => `  // \u26A0 GAP: no snippet for ${s.action} \u2014 scaffold_snippet then re-plan.`
+  );
+  const header = [`import { test } from '@playwright/test';`];
+  if (usesFaker) header.push(`import { faker } from '@faker-js/faker';`);
+  const code = `${header.join("\n")}
+${[...importLines].join("\n")}
+
+test(${JSON.stringify(opts.title ?? `plan: ${plan.target}`)}, async ({ page }) => {
+${[...warnings, ...callLines].join("\n")}
+});
+`;
+  return { code, missingFixtures: [...missing], complete: plan.runnable && missing.size === 0 };
+}
+
 // src/server/lockfile.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs12 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 var import_node_os4 = require("node:os");
-var import_node_path14 = require("node:path");
+var import_node_path19 = require("node:path");
 init_launch_kit_paths();
 function lockDir(projectRoot) {
   if (projectRoot) {
-    return (0, import_node_path14.join)(projectRoot, LAUNCHSECURE_DIR);
+    return (0, import_node_path19.join)(projectRoot, LAUNCHSECURE_DIR);
   }
-  return (0, import_node_path14.join)((0, import_node_os4.homedir)(), LAUNCHSECURE_DIR);
+  return (0, import_node_path19.join)((0, import_node_os4.homedir)(), LAUNCHSECURE_DIR);
 }
 function lockPath(projectRoot) {
-  return (0, import_node_path14.join)(lockDir(projectRoot), "launch-chart.lock");
+  return (0, import_node_path19.join)(lockDir(projectRoot), "launch-chart.lock");
 }
 var _activeProjectRoot;
 function readLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   const p = lockPath(root);
-  if (!(0, import_node_fs12.existsSync)(p)) {
+  if (!(0, import_node_fs14.existsSync)(p)) {
     if (root) {
       const globalP = lockPath();
-      if ((0, import_node_fs12.existsSync)(globalP)) {
+      if ((0, import_node_fs14.existsSync)(globalP)) {
         try {
-          const data = JSON.parse((0, import_node_fs12.readFileSync)(globalP, "utf-8"));
+          const data = JSON.parse((0, import_node_fs14.readFileSync)(globalP, "utf-8"));
           if (typeof data.pid === "number" && typeof data.port === "number" && data.cwd === root) {
             return data;
           }
@@ -29481,7 +30024,7 @@ function readLock(projectRoot) {
     return null;
   }
   try {
-    const data = JSON.parse((0, import_node_fs12.readFileSync)(p, "utf-8"));
+    const data = JSON.parse((0, import_node_fs14.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
     return data;
   } catch {
@@ -29518,7 +30061,7 @@ function getLiveLock(projectRoot) {
   const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
   if (!live) {
     try {
-      (0, import_node_fs12.unlinkSync)(lockPath(root));
+      (0, import_node_fs14.unlinkSync)(lockPath(root));
     } catch {
     }
     return null;
@@ -29528,7 +30071,7 @@ function getLiveLock(projectRoot) {
 function clearLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   try {
-    (0, import_node_fs12.unlinkSync)(lockPath(root));
+    (0, import_node_fs14.unlinkSync)(lockPath(root));
   } catch {
   }
 }
@@ -29537,20 +30080,20 @@ function clearLock(projectRoot) {
 init_config();
 
 // src/server/graph/core/parser-registry.ts
-var import_node_path25 = require("node:path");
+var import_node_path30 = require("node:path");
 
 // src/server/graph/parsers/ts/typescript-project.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path23 = require("node:path");
 init_config();
 
 // src/server/graph/core/resolve-paths.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path21 = require("node:path");
 
 // src/server/graph/core/walk.ts
-var import_node_fs13 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path20 = require("node:path");
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -29560,12 +30103,12 @@ var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
 ]);
 function walk(dir, exts) {
   const results = [];
-  if (!(0, import_node_fs13.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path15.join)(dir, entry.name);
+  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 (entry.isDirectory()) {
       results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path15.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path20.extname)(entry.name))) {
       results.push(full);
     }
   }
@@ -29573,15 +30116,15 @@ function walk(dir, exts) {
 }
 function walkWithIgnore(dir, exts, opts = {}) {
   const results = [];
-  if (!(0, import_node_fs13.existsSync)(dir)) return results;
+  if (!(0, import_node_fs15.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_fs13.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".")) continue;
       if (skip.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path15.join)(dir, entry.name), exts, opts));
-    } else if (exts.includes((0, import_node_path15.extname)(entry.name))) {
-      results.push((0, import_node_path15.join)(dir, entry.name));
+      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));
     }
   }
   return results;
@@ -29589,9 +30132,9 @@ function walkWithIgnore(dir, exts, opts = {}) {
 
 // src/server/graph/core/resolve-paths.ts
 function hasSqlFiles(dir) {
-  if (!(0, import_node_fs14.existsSync)(dir)) return false;
+  if (!(0, import_node_fs16.existsSync)(dir)) return false;
   try {
-    return (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true }).some(
+    return (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true }).some(
       (e) => e.isFile() && e.name.endsWith(".sql")
     );
   } catch {
@@ -29599,27 +30142,27 @@ function hasSqlFiles(dir) {
   }
 }
 function hasNestedMigrationSql(dir) {
-  if (!(0, import_node_fs14.existsSync)(dir)) return false;
+  if (!(0, import_node_fs16.existsSync)(dir)) return false;
   try {
-    return (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true }).some(
-      (e) => e.isDirectory() && (0, import_node_fs14.existsSync)((0, import_node_path16.join)(dir, e.name, "migration.sql"))
+    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"))
     );
   } catch {
     return false;
   }
 }
 function resolveDbFromDir(dir) {
-  if (!(0, import_node_fs14.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
-  const schemaPath = (0, import_node_path16.join)(dir, "schema.prisma");
-  if ((0, import_node_fs14.existsSync)(schemaPath)) {
-    const migrationsDir2 = (0, import_node_path16.join)(dir, "migrations");
+  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");
     return {
       kind: "prisma",
       schemaPath,
-      migrationsDir: (0, import_node_fs14.existsSync)(migrationsDir2) ? migrationsDir2 : null
+      migrationsDir: (0, import_node_fs16.existsSync)(migrationsDir2) ? migrationsDir2 : null
     };
   }
-  const migrationsDir = (0, import_node_path16.join)(dir, "migrations");
+  const migrationsDir = (0, import_node_path21.join)(dir, "migrations");
   if (hasSqlFiles(migrationsDir) || hasNestedMigrationSql(migrationsDir)) {
     return { kind: "sql-migrations", migrationsDir, schemaPath: null };
   }
@@ -29630,19 +30173,19 @@ function resolveDbFromDir(dir) {
 }
 function detectDbConfig(rootDir, config) {
   if (config.paths?.dbDir) {
-    return resolveDbFromDir((0, import_node_path16.join)(rootDir, config.paths.dbDir));
+    return resolveDbFromDir((0, import_node_path21.join)(rootDir, config.paths.dbDir));
   }
-  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path16.join)("db", "migrations"), "migrations"];
+  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path21.join)("db", "migrations"), "migrations"];
   for (const c of candidates) {
-    const dir = (0, import_node_path16.join)(rootDir, c);
+    const dir = (0, import_node_path21.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_path16.join)(rootDir, config.paths.dbDir);
-  if (dbConfig.kind === "prisma") return (0, import_node_path16.dirname)(dbConfig.schemaPath);
+  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 (dbConfig.kind === "sql-migrations") return dbConfig.migrationsDir;
   return null;
 }
@@ -29673,16 +30216,16 @@ var NON_SOURCE_DIRS = /* @__PURE__ */ new Set([
   "libs"
 ]);
 function dirHasTSFiles(dir) {
-  if (!(0, import_node_fs14.existsSync)(dir)) return false;
+  if (!(0, import_node_fs16.existsSync)(dir)) return false;
   try {
     const stack = [dir];
     while (stack.length > 0) {
       const cur = stack.pop();
-      const entries = (0, import_node_fs14.readdirSync)(cur, { withFileTypes: true });
+      const entries = (0, import_node_fs16.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_path16.join)(cur, e.name));
+          stack.push((0, import_node_path21.join)(cur, e.name));
         }
       }
     }
@@ -29691,15 +30234,15 @@ function dirHasTSFiles(dir) {
   return false;
 }
 function collectCodeBearingChildren(dir, extraSkip) {
-  if (!(0, import_node_fs14.existsSync)(dir)) return [];
+  if (!(0, import_node_fs16.existsSync)(dir)) return [];
   const out = [];
   try {
-    for (const entry of (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs16.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_path16.join)(dir, entry.name);
+      const full = (0, import_node_path21.join)(dir, entry.name);
       if (dirHasTSFiles(full)) out.push(full);
     }
   } catch {
@@ -29711,7 +30254,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_path16.isAbsolute)(r) ? r : (0, import_node_path16.resolve)(rootDir, r);
+      const abs = (0, import_node_path21.isAbsolute)(r) ? r : (0, import_node_path21.resolve)(rootDir, r);
       roots2.add(abs);
     }
     return [...roots2];
@@ -29720,7 +30263,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_path16.basename)(srcDir)]);
+    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path21.basename)(srcDir)]);
     for (const c of collectCodeBearingChildren(rootDir, skipSrcWrapper)) roots.add(c);
   }
   return [...roots];
@@ -29732,10 +30275,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_path16.join)(dir, name);
-      if (!seen.has(full) && (0, import_node_fs14.existsSync)(full)) {
+      const full = (0, import_node_path21.join)(dir, name);
+      if (!seen.has(full) && (0, import_node_fs16.existsSync)(full)) {
         try {
-          if ((0, import_node_fs14.statSync)(full).isFile()) {
+          if ((0, import_node_fs16.statSync)(full).isFile()) {
             seen.add(full);
             out.push(full);
           }
@@ -29750,22 +30293,22 @@ function resolveProjectPaths(rootDir, config) {
   let srcDir;
   let appDir;
   if (config.paths?.appDir) {
-    appDir = (0, import_node_path16.join)(rootDir, config.paths.appDir);
-    srcDir = config.paths.srcDir ? (0, import_node_path16.join)(rootDir, config.paths.srcDir) : (0, import_node_path16.dirname)(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);
   } else {
-    const srcApp = (0, import_node_path16.join)(rootDir, "src", "app");
-    const rootApp = (0, import_node_path16.join)(rootDir, "app");
-    if ((0, import_node_fs14.existsSync)(srcApp)) {
-      srcDir = (0, import_node_path16.join)(rootDir, "src");
+    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");
       appDir = srcApp;
-    } else if ((0, import_node_fs14.existsSync)(rootApp)) {
+    } else if ((0, import_node_fs16.existsSync)(rootApp)) {
       srcDir = rootDir;
       appDir = rootApp;
     } else {
       return null;
     }
   }
-  const apiDir = (0, import_node_path16.join)(appDir, "api");
+  const apiDir = (0, import_node_path21.join)(appDir, "api");
   const dbConfig = detectDbConfig(rootDir, config);
   const dbDir = detectDbDir(rootDir, config, dbConfig);
   const srcRoots = detectSrcRoots(rootDir, srcDir, appDir, config);
@@ -29792,25 +30335,25 @@ var CLASSIFICATION_TO_LAYER = {
   external: "ui"
 };
 function toNodeId(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path18.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path23.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path18.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path23.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_path18.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path18.join)(base, "index.ts"), (0, import_node_path18.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs16.existsSync)(c) && (0, import_node_fs16.statSync)(c).isFile()) return c;
+  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;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path18.join)((0, import_node_path18.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path18.join)(base, "index.ts"), (0, import_node_path18.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs16.existsSync)(c) && (0, import_node_fs16.statSync)(c).isFile()) return c;
+  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;
   }
   return null;
 }
@@ -29831,7 +30374,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path18.basename)(resolved);
+      const targetBn = (0, import_node_path23.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -29858,12 +30401,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_path18.basename)(absPath);
+    const bn = (0, import_node_path23.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_path18.relative)(srcDir, (0, import_node_path18.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path23.relative)(srcDir, (0, import_node_path23.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -29888,10 +30431,10 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path18.basename)(absPath, (0, import_node_path18.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  return (0, import_node_path23.basename)(absPath, (0, import_node_path23.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
 function filePathToAppRoute(appDir, absPath) {
-  let route = ("/" + (0, import_node_path18.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
+  let route = ("/" + (0, import_node_path23.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
   route = route.replace(/\/\([^)]+\)/g, "");
   route = route.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "*$1?");
   route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
@@ -30139,7 +30682,7 @@ function generate(rootDir) {
   const apiNodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const routeToNodeId = /* @__PURE__ */ new Map();
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path18.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path23.basename)(f).startsWith("index."));
   for (const absPath of fileSet) {
     const id = toNodeId(srcDir, rootDir, absPath);
     const type = classifyType(absPath, id);
@@ -30299,7 +30842,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path18.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path23.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -30649,7 +31192,7 @@ var typescriptProjectParser = {
 };
 
 // src/server/graph/parsers/db/prisma-schema.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs19 = require("node:fs");
 init_config();
 function parseModels(content) {
   const nodes = [];
@@ -30742,7 +31285,7 @@ function parseEnums(content) {
 }
 function detect2(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs17.existsSync)(paths.dbConfig.schemaPath);
+  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs19.existsSync)(paths.dbConfig.schemaPath);
 }
 function generate2(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
@@ -30759,7 +31302,7 @@ function generate2(rootDir) {
     };
   }
   const schemaPath = paths.dbConfig.schemaPath;
-  const content = (0, import_node_fs17.readFileSync)(schemaPath, "utf-8");
+  const content = (0, import_node_fs19.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -30816,8 +31359,8 @@ var prismaSchemaParser = {
 };
 
 // src/server/graph/parsers/db/sql-migrations.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path24 = require("node:path");
 var import_pgsql_parser = require("pgsql-parser");
 init_config();
 var PG_TO_PRISMA = {
@@ -30851,15 +31394,15 @@ function pgTypeToPrisma(pgType) {
   return PG_TO_PRISMA[upper] ?? upper;
 }
 function discoverMigrationFiles(migrationsDir) {
-  if (!(0, import_node_fs18.existsSync)(migrationsDir)) return [];
+  if (!(0, import_node_fs20.existsSync)(migrationsDir)) return [];
   const out = [];
-  const entries = (0, import_node_fs18.readdirSync)(migrationsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = (0, import_node_fs20.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_path19.join)(migrationsDir, entry.name, "migration.sql");
-      if ((0, import_node_fs18.existsSync)(sqlPath)) out.push(sqlPath);
+      const sqlPath = (0, import_node_path24.join)(migrationsDir, entry.name, "migration.sql");
+      if ((0, import_node_fs20.existsSync)(sqlPath)) out.push(sqlPath);
     } else if (entry.isFile() && entry.name.endsWith(".sql")) {
-      out.push((0, import_node_path19.join)(migrationsDir, entry.name));
+      out.push((0, import_node_path24.join)(migrationsDir, entry.name));
     }
   }
   return out;
@@ -30904,7 +31447,7 @@ function parseMigrations(migrationsDir, dialect = postgresDialect) {
   };
   if (!migrationsDir) return state;
   for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
-    const sql = (0, import_node_fs18.readFileSync)(sqlPath, "utf-8");
+    const sql = (0, import_node_fs20.readFileSync)(sqlPath, "utf-8");
     let ast;
     try {
       ast = dialect.parse(sql);
@@ -31473,8 +32016,8 @@ function indexIsPrismaUncoverable(idx) {
   return idx.hasPredicate || idx.hasExpressions || idx.method !== "btree";
 }
 function loadPrismaState(schemaPath) {
-  if (!schemaPath || !(0, import_node_fs18.existsSync)(schemaPath)) return null;
-  const content = (0, import_node_fs18.readFileSync)(schemaPath, "utf-8");
+  if (!schemaPath || !(0, import_node_fs20.existsSync)(schemaPath)) return null;
+  const content = (0, import_node_fs20.readFileSync)(schemaPath, "utf-8");
   const tables = /* @__PURE__ */ new Map();
   const enums = /* @__PURE__ */ new Map();
   const relations = [];
@@ -31881,7 +32424,7 @@ function generate3(rootDir) {
   const migrationFiles = migrationsDir ? discoverMigrationFiles(migrationsDir) : [];
   let migrationNodeCount = 0;
   for (const sqlPath of migrationFiles) {
-    const sql = (0, import_node_fs18.readFileSync)(sqlPath, "utf-8");
+    const sql = (0, import_node_fs20.readFileSync)(sqlPath, "utf-8");
     const name = deriveMigrationName(sqlPath);
     let ast;
     try {
@@ -32199,14 +32742,14 @@ var fetchResolverParser = {
 };
 
 // src/server/graph/parsers/crosslayer/api-annotations.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs21 = require("node:fs");
+var import_node_path25 = 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_path20.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path25.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path20.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path25.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -32251,7 +32794,7 @@ var apiAnnotationsParser = {
     const flaggedEdges = [];
     const seenEdge = /* @__PURE__ */ new Set();
     for (const absPath of files) {
-      const content = (0, import_node_fs19.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs21.readFileSync)(absPath, "utf-8");
       const sourceId = toNodeId2(srcDir, rootDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
       let match;
@@ -32295,14 +32838,14 @@ var apiAnnotationsParser = {
 };
 
 // src/server/graph/parsers/crosslayer/url-literal-scanner.ts
-var import_node_fs20 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs22 = require("node:fs");
+var import_node_path26 = require("node:path");
 init_config();
 var URL_LITERAL_RE = /['"`](\/[a-zA-Z][^'"`\s]*?)['"`]/g;
 function toNodeId3(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path21.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path26.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path21.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path26.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -32346,7 +32889,7 @@ var urlLiteralScannerParser = {
     for (const absPath of files) {
       const sourceId = toNodeId3(srcDir, rootDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
-      const content = (0, import_node_fs20.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs22.readFileSync)(absPath, "utf-8");
       let match;
       URL_LITERAL_RE.lastIndex = 0;
       while ((match = URL_LITERAL_RE.exec(content)) !== null) {
@@ -32377,8 +32920,8 @@ var urlLiteralScannerParser = {
 };
 
 // src/server/graph/parsers/static/static-values.ts
-var import_node_fs21 = require("node:fs");
-var import_node_path22 = require("node:path");
+var import_node_fs23 = require("node:fs");
+var import_node_path27 = require("node:path");
 init_config();
 var parseCode = null;
 function tryLoadTreeSitter() {
@@ -32415,21 +32958,21 @@ function extractEnumValues(rootDir) {
   const schemaPaths = [];
   if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath) {
     schemaPaths.push(paths.dbConfig.schemaPath);
-    schemaPaths.push((0, import_node_path22.join)((0, import_node_path22.dirname)(paths.dbConfig.schemaPath), "schema"));
+    schemaPaths.push((0, import_node_path27.join)((0, import_node_path27.dirname)(paths.dbConfig.schemaPath), "schema"));
   } else {
-    schemaPaths.push((0, import_node_path22.join)(rootDir, "prisma", "schema.prisma"));
-    schemaPaths.push((0, import_node_path22.join)(rootDir, "prisma", "schema"));
+    schemaPaths.push((0, import_node_path27.join)(rootDir, "prisma", "schema.prisma"));
+    schemaPaths.push((0, import_node_path27.join)(rootDir, "prisma", "schema"));
   }
   let content = "";
   for (const p of schemaPaths) {
-    if ((0, import_node_fs21.existsSync)(p)) {
+    if ((0, import_node_fs23.existsSync)(p)) {
       try {
-        const stat = (0, import_node_fs21.statSync)(p);
+        const stat = (0, import_node_fs23.statSync)(p);
         if (stat.isFile()) {
-          content = (0, import_node_fs21.readFileSync)(p, "utf-8");
+          content = (0, import_node_fs23.readFileSync)(p, "utf-8");
         } else if (stat.isDirectory()) {
-          const files = (0, import_node_fs21.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
-          content = files.map((f) => (0, import_node_fs21.readFileSync)((0, import_node_path22.join)(p, f), "utf-8")).join("\n");
+          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");
         }
       } catch {
         continue;
@@ -32587,27 +33130,27 @@ function extractSeedData(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
   const candidates = [];
   if (paths?.dbDir) {
-    candidates.push((0, import_node_path22.join)(paths.dbDir, "seed.ts"));
-    candidates.push((0, import_node_path22.join)(paths.dbDir, "seed.js"));
+    candidates.push((0, import_node_path27.join)(paths.dbDir, "seed.ts"));
+    candidates.push((0, import_node_path27.join)(paths.dbDir, "seed.js"));
   } else {
-    candidates.push((0, import_node_path22.join)(rootDir, "prisma", "seed.ts"));
-    candidates.push((0, import_node_path22.join)(rootDir, "prisma", "seed.js"));
+    candidates.push((0, import_node_path27.join)(rootDir, "prisma", "seed.ts"));
+    candidates.push((0, import_node_path27.join)(rootDir, "prisma", "seed.js"));
   }
-  const baseRoots = paths?.srcRoots ?? [(0, import_node_path22.join)(rootDir, "src")];
+  const baseRoots = paths?.srcRoots ?? [(0, import_node_path27.join)(rootDir, "src")];
   for (const root of baseRoots) {
-    candidates.push((0, import_node_path22.join)(root, "server", "lib", "system-tags.ts"));
+    candidates.push((0, import_node_path27.join)(root, "server", "lib", "system-tags.ts"));
   }
   const seedFiles = candidates.filter((p) => {
     try {
-      return (0, import_node_fs21.existsSync)(p) && (0, import_node_fs21.statSync)(p).isFile();
+      return (0, import_node_fs23.existsSync)(p) && (0, import_node_fs23.statSync)(p).isFile();
     } catch {
       return false;
     }
   });
   const useTreeSitter = tryLoadTreeSitter();
   for (const filePath of seedFiles) {
-    const content = (0, import_node_fs21.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path22.relative)(rootDir, filePath);
+    const content = (0, import_node_fs23.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path27.relative)(rootDir, filePath);
     const seeded = detectSeededArrays(content, relPath);
     let astRoot = null;
     if (useTreeSitter && parseCode) {
@@ -32701,11 +33244,11 @@ function extractSeedData(rootDir) {
   return { nodes, edges };
 }
 function walkDir(dir, exts) {
-  if (!(0, import_node_fs21.existsSync)(dir)) return [];
+  if (!(0, import_node_fs23.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs21.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs23.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
-    const full = (0, import_node_path22.join)(dir, entry.name);
+    const full = (0, import_node_path27.join)(dir, entry.name);
     if (entry.isDirectory()) results.push(...walkDir(full, exts));
     else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(full);
   }
@@ -32714,7 +33257,7 @@ function walkDir(dir, exts) {
 function extractConstants(rootDir) {
   const nodes = [];
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  const roots = paths?.srcRoots ?? [(0, import_node_path22.join)(rootDir, "src")];
+  const roots = paths?.srcRoots ?? [(0, import_node_path27.join)(rootDir, "src")];
   const seenFile = /* @__PURE__ */ new Set();
   const allFiles = [];
   for (const root of roots) {
@@ -32727,8 +33270,8 @@ function extractConstants(rootDir) {
   }
   if (allFiles.length === 0) return { nodes };
   for (const filePath of allFiles) {
-    const content = (0, import_node_fs21.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path22.relative)(rootDir, filePath);
+    const content = (0, import_node_fs23.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path27.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) {
@@ -32762,13 +33305,13 @@ function extractConstants(rootDir) {
 }
 function detect4(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs21.existsSync)(paths.dbConfig.schemaPath)) {
+  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs23.existsSync)(paths.dbConfig.schemaPath)) {
     return true;
   }
   if (paths?.dbDir) {
-    if ((0, import_node_fs21.existsSync)((0, import_node_path22.join)(paths.dbDir, "seed.ts")) || (0, import_node_fs21.existsSync)((0, import_node_path22.join)(paths.dbDir, "seed.js"))) return true;
+    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;
   }
-  return (0, import_node_fs21.existsSync)((0, import_node_path22.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs21.existsSync)((0, import_node_path22.join)(rootDir, "prisma", "seed.ts"));
+  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"));
 }
 function generate4(rootDir) {
   const enumResult = extractEnumValues(rootDir);
@@ -32843,8 +33386,8 @@ var staticValuesParser = {
 };
 
 // src/server/graph/parsers/crosslayer/static-ref-scanner.ts
-var import_node_fs22 = require("node:fs");
-var import_node_path23 = require("node:path");
+var import_node_fs24 = require("node:fs");
+var import_node_path28 = require("node:path");
 init_config();
 var MIN_VALUE_LENGTH = 4;
 var SKIP_VALUES = /* @__PURE__ */ new Set([
@@ -33019,11 +33562,11 @@ var staticRefScannerParser = {
     const seen = /* @__PURE__ */ new Set();
     let filesScanned = 0;
     for (const absPath of files) {
-      const relFromSrc = (0, import_node_path23.relative)(srcDir, absPath).replace(/\\/g, "/");
-      const sourceId = relFromSrc.startsWith("..") ? (0, import_node_path23.relative)(rootDir, absPath).replace(/\\/g, "/") : relFromSrc;
+      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 sourceLayer = uiNodeIds.has(sourceId) ? "ui" : apiNodeIds.has(sourceId) ? "api" : null;
       if (!sourceLayer) continue;
-      const content = (0, import_node_fs22.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs24.readFileSync)(absPath, "utf-8");
       filesScanned++;
       let fileRefs;
       if (parseCode2) {
@@ -33065,13 +33608,13 @@ var staticRefScannerParser = {
 };
 
 // src/server/graph/parsers/crosslayer/middleware-gates.ts
-var import_node_path24 = require("node:path");
+var import_node_path29 = require("node:path");
 init_ts_extractor();
 init_config();
 function toNodeId4(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path24.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path29.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path24.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path29.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -33352,7 +33895,7 @@ var ParserRegistry = class {
     return all2;
   }
 };
-function registerBuiltins2(registry, disabled) {
+function registerBuiltins3(registry, disabled) {
   const builtins = [
     typescriptProjectParser,
     prismaSchemaParser,
@@ -33373,7 +33916,7 @@ function registerBuiltins2(registry, disabled) {
 function loadCustomParsers(registry, config, rootDir, disabled) {
   for (const entry of config.parsers?.custom ?? []) {
     try {
-      const absPath = (0, import_node_path25.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path30.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const parser = "default" in mod ? mod.default : mod;
       if (disabled.has(parser.id)) continue;
@@ -33396,14 +33939,14 @@ function loadCustomParsers(registry, config, rootDir, disabled) {
 function createRegistry(config, rootDir) {
   const registry = new ParserRegistry();
   const disabled = new Set(config.parsers?.disabled ?? []);
-  registerBuiltins2(registry, disabled);
+  registerBuiltins3(registry, disabled);
   loadCustomParsers(registry, config, rootDir, disabled);
   return registry;
 }
 
 // src/server/graph/core/language-detection.ts
-var import_node_fs23 = require("node:fs");
-var import_node_path26 = require("node:path");
+var import_node_fs25 = require("node:fs");
+var import_node_path31 = require("node:path");
 init_launch_kit_paths();
 var EXTENSION_TO_LANGUAGE = {
   // Web / Frontend
@@ -33516,10 +34059,10 @@ var AUXILIARY_LANGUAGES = /* @__PURE__ */ new Set([
 ]);
 function walkForExtensions(dir, extCounts, depth = 0) {
   if (depth > 10) return;
-  if (!(0, import_node_fs23.existsSync)(dir)) return;
+  if (!(0, import_node_fs25.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs23.readdirSync)(dir, { withFileTypes: true });
+    entries = (0, import_node_fs25.readdirSync)(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -33527,9 +34070,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_path26.join)(dir, entry.name), extCounts, depth + 1);
+      walkForExtensions((0, import_node_path31.join)(dir, entry.name), extCounts, depth + 1);
     } else {
-      const ext = (0, import_node_path26.extname)(entry.name).toLowerCase();
+      const ext = (0, import_node_path31.extname)(entry.name).toLowerCase();
       if (ext && EXTENSION_TO_LANGUAGE[ext]) {
         extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
       }
@@ -33570,13 +34113,13 @@ function detectLanguages(rootDir, supportedLanguages) {
 }
 
 // src/server/graph/core/audit-core.ts
-var import_node_fs25 = require("node:fs");
-var import_node_path28 = require("node:path");
+var import_node_fs27 = require("node:fs");
+var import_node_path33 = require("node:path");
 init_launch_kit_paths();
 
 // src/server/graph/core/audit-security.ts
-var import_node_fs24 = require("node:fs");
-var import_node_path27 = require("node:path");
+var import_node_fs26 = require("node:fs");
+var import_node_path32 = require("node:path");
 init_ts_extractor();
 init_config();
 function collectSourceFiles(rootDir) {
@@ -33601,9 +34144,9 @@ function collectSourceFiles(rootDir) {
   return out;
 }
 function toNodeId5(rootDir, srcDir, absPath) {
-  const relFromSrc = (0, import_node_path27.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path32.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path27.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path32.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -33713,18 +34256,18 @@ function collectDeclaredEnvKeys(rootDir) {
   const files = [];
   let entries = [];
   try {
-    entries = (0, import_node_fs24.readdirSync)(rootDir);
+    entries = (0, import_node_fs26.readdirSync)(rootDir);
   } catch {
     return { keys, files };
   }
   for (const name of entries) {
     if (!name.startsWith(".env")) continue;
-    const abs = (0, import_node_path27.join)(rootDir, name);
-    if (!(0, import_node_fs24.existsSync)(abs)) continue;
+    const abs = (0, import_node_path32.join)(rootDir, name);
+    if (!(0, import_node_fs26.existsSync)(abs)) continue;
     files.push(name);
     let content = "";
     try {
-      content = (0, import_node_fs24.readFileSync)(abs, "utf-8");
+      content = (0, import_node_fs26.readFileSync)(abs, "utf-8");
     } catch {
       continue;
     }
@@ -33911,10 +34454,10 @@ function checkHardcodedUrlFallback(rootDir, core) {
 
 // src/server/graph/core/audit-core.ts
 function readGraphFile(rootDir, layer) {
-  const filePath = (0, import_node_path28.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
-  if (!(0, import_node_fs25.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path33.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
+  if (!(0, import_node_fs27.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs25.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs27.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -33956,15 +34499,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_path28.join)(rootDir, "src", "config", "route-permissions.ts");
-  if (!(0, import_node_fs25.existsSync)(routePermsPath)) {
+  const routePermsPath = (0, import_node_path33.join)(rootDir, "src", "config", "route-permissions.ts");
+  if (!(0, import_node_fs27.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_fs25.readFileSync)(routePermsPath, "utf-8");
+  const routePermsContent = (0, import_node_fs27.readFileSync)(routePermsPath, "utf-8");
   const registeredRoutes = /* @__PURE__ */ new Set();
   const routeEntryRe = /path:\s*'([^']+)'/g;
   let rm;
@@ -34049,15 +34592,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_path28.join)(rootDir, "src", "config", "route-permissions.ts");
-  if (!(0, import_node_fs25.existsSync)(routePermsPath)) {
+  const routePermsPath = (0, import_node_path33.join)(rootDir, "src", "config", "route-permissions.ts");
+  if (!(0, import_node_fs27.existsSync)(routePermsPath)) {
     return buildSkipped(
       "static",
       "unenforced_permissions",
       `no src/config/route-permissions.ts to compare seed permissions against`
     );
   }
-  const routePermsContent = (0, import_node_fs25.readFileSync)(routePermsPath, "utf-8");
+  const routePermsContent = (0, import_node_fs27.readFileSync)(routePermsPath, "utf-8");
   for (const perm of permissions) {
     const regex = new RegExp(`permission:\\s*['"]${perm.key}['"]`);
     if (!regex.test(routePermsContent)) {
@@ -34093,9 +34636,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_path28.join)(rootDir, "src", node.id);
-    if (!(0, import_node_fs25.existsSync)(filePath)) continue;
-    const content = (0, import_node_fs25.readFileSync)(filePath, "utf-8");
+    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");
     let m;
     allCapsRe.lastIndex = 0;
     while ((m = allCapsRe.exec(content)) !== null) {
@@ -34200,26 +34743,26 @@ function runAudit(rootDir, layer, check) {
 }
 
 // src/server/graph/core/projects.ts
-var import_node_path31 = require("node:path");
+var import_node_path36 = require("node:path");
 
 // src/server/lib/worktree.ts
-var import_node_path30 = require("node:path");
+var import_node_path35 = require("node:path");
 
 // src/server/orbit/registry.ts
-var import_node_fs26 = require("node:fs");
+var import_node_fs28 = require("node:fs");
 var import_node_os5 = require("node:os");
-var import_node_path29 = require("node:path");
+var import_node_path34 = require("node:path");
 init_launch_kit_paths();
-var REGISTRY_DIR = (0, import_node_path29.join)((0, import_node_os5.homedir)(), LAUNCHSECURE_DIR, "orbit");
-var REGISTRY_PATH = (0, import_node_path29.join)(REGISTRY_DIR, "state.json");
-var LOCK_PATH = (0, import_node_path29.join)(REGISTRY_DIR, "state.json.lock");
+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");
 function emptyRegistry() {
   return { version: 1, worktrees: {} };
 }
 function readRegistry() {
-  if (!(0, import_node_fs26.existsSync)(REGISTRY_PATH)) return emptyRegistry();
+  if (!(0, import_node_fs28.existsSync)(REGISTRY_PATH)) return emptyRegistry();
   try {
-    const parsed = JSON.parse((0, import_node_fs26.readFileSync)(REGISTRY_PATH, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs28.readFileSync)(REGISTRY_PATH, "utf-8"));
     if (parsed?.version === 1 && parsed.worktrees && typeof parsed.worktrees === "object") {
       return parsed;
     }
@@ -34249,7 +34792,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_path30.isAbsolute)(projectRoot) ? projectRoot : (0, import_node_path30.resolve)(monorepoRoot, projectRoot);
+    return (0, import_node_path35.isAbsolute)(projectRoot) ? projectRoot : (0, import_node_path35.resolve)(monorepoRoot, projectRoot);
   }
   const worktree = typeof args.worktree === "string" ? args.worktree.trim() : "";
   if (worktree) {
@@ -34268,7 +34811,7 @@ function listProjects(monorepoRoot) {
   return entries.map((p) => ({
     name: p.name,
     root: p.root,
-    absoluteRoot: (0, import_node_path31.resolve)(monorepoRoot, p.root)
+    absoluteRoot: (0, import_node_path36.resolve)(monorepoRoot, p.root)
   }));
 }
 function resolveProject(name, projects) {
@@ -34677,6 +35220,53 @@ USE THIS FOR: "are there unsafe migrations on this branch", "audit the migration
       required: ["from", "to"]
     }
   },
+  {
+    name: "scaffold_snippet",
+    description: 'Scaffold a standardised test "snippet" for a context-graph action/state node. Returns a ready-to-complete snippet file: requires/produces are filled from the context graph (certain); params + the run() body are left as TODOs for you to fill from the endpoint source.\n\nUSE THIS FOR: turning a context `action` (e.g. "create tag", "pay via UPI") into a reusable Playwright snippet in the project\'s standard shape, instead of hand-writing the requires/produces wiring. Requires the `context` layer (run generate_graph first).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: 'Context node id (e.g. "action:app/api/orgs/[orgSlug]/tags/route.ts") or the bare key (the "action:"/"state:" prefix is added if missing).' },
+        project: { type: "string", description: PROJECT_PARAM_DESCRIPTION },
+        worktree: { type: "string", description: WORKTREE_PARAM_DESCRIPTION2 },
+        project_root: { type: "string", description: PROJECT_ROOT_PARAM_DESCRIPTION2 }
+      },
+      required: ["target"]
+    }
+  },
+  {
+    name: "test_plan",
+    description: 'Assemble the ordered snippet chain needed to exercise a target action. Walks the context graph\'s requires/produces backward from the target (prerequisites first, target last), binds each step to its snippet (from tests/snippets/), and flags gaps \u2014 a required state nothing produces, an action with no snippet, or a cycle.\n\nUSE THIS FOR: "what\'s the test plan for creating a tag", "what setup does action X need". Returns { target, steps[], gaps[], runnable }. Requires the `context` layer (run generate_graph first). When runnable is false, the gaps tell you which snippets to scaffold next.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: 'Context action node id (e.g. "action:app/api/orgs/[orgSlug]/tags/route.ts") or the bare key.' },
+        snippets_dir: { type: "string", description: `Snippets directory relative to project root. Default "${DEFAULT_SNIPPETS_DIR}".` },
+        project: { type: "string", description: PROJECT_PARAM_DESCRIPTION },
+        worktree: { type: "string", description: WORKTREE_PARAM_DESCRIPTION2 },
+        project_root: { type: "string", description: PROJECT_ROOT_PARAM_DESCRIPTION2 }
+      },
+      required: ["target"]
+    }
+  },
+  {
+    name: "generate_spec",
+    description: 'Generate a runnable Playwright .spec.ts from a target action: builds the test_plan, then emits imports + ordered `await snippet.run(page, {...})` calls. Params are auto-classified \u2014 secrets \u2192 process.env, free-form (name/color/icon/description) \u2192 faker.*, and state-bound (email/slug/id) \u2192 TODO + returned in missingFixtures. Supply those via `fixtures`.\n\nUSE THIS FOR: "generate the test for creating a tag". Returns { code, missingFixtures, complete }. complete:true means every state-bound param had a fixture (secrets via env + faker auto). Requires the `context` layer + snippets.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Context action node id (or bare key)." },
+        fixtures: { type: "object", description: 'param name -> value for state-bound params (e.g. {"email":"...","orgSlug":"..."}). Overrides classification.', additionalProperties: true },
+        title: { type: "string", description: "Test title. Defaults to the target." },
+        spec_dir: { type: "string", description: 'Where the spec will live (for import paths). Default "tests/generated".' },
+        snippets_dir: { type: "string", description: `Snippets directory. Default "${DEFAULT_SNIPPETS_DIR}".` },
+        project: { type: "string", description: PROJECT_PARAM_DESCRIPTION },
+        worktree: { type: "string", description: WORKTREE_PARAM_DESCRIPTION2 },
+        project_root: { type: "string", description: PROJECT_ROOT_PARAM_DESCRIPTION2 }
+      },
+      required: ["target"]
+    }
+  },
   {
     name: "auth_coverage_report",
     description: 'Aggregate every API endpoint by its auth[] wrapper(s) \u2014 surfaces endpoints with empty auth, groups by module, shows which auth strategies dominate. Computed from api.json endpoint auth field (100% populated).\n\nUSE THIS FOR: "are there unauthenticated endpoints", "which auth wrappers are in use", "audit auth strategy consistency across modules". Paginated. Returns { total, by_strategy: {strategy: count}, unauthenticated: [endpoint_ids], by_module: {module: {total, by_strategy}} } plus the paginated endpoint list.',
@@ -35660,12 +36250,12 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui" || layer === "api") return (0, import_node_path33.join)(rootDir, "src", nodeId);
-  if (layer === "db") return (0, import_node_path33.join)(rootDir, "prisma", "schema.prisma");
-  const withSrc = (0, import_node_path33.join)(rootDir, "src", nodeId);
-  if ((0, import_node_fs28.existsSync)(withSrc)) return withSrc;
-  const direct = (0, import_node_path33.join)(rootDir, nodeId);
-  if ((0, import_node_fs28.existsSync)(direct)) return direct;
+  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;
   return null;
 }
 function handleInspectNode(args) {
@@ -35933,11 +36523,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs28.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs30.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs28.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs30.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -36156,11 +36746,11 @@ function handleStartChartServer(args) {
     });
   }
   const entryPath = process.argv[1];
-  const logDir = (0, import_node_path33.join)((0, import_node_os6.homedir)(), LAUNCHSECURE_DIR);
-  (0, import_node_fs28.mkdirSync)(logDir, { recursive: true });
-  const logPath = (0, import_node_path33.join)(logDir, "launch-chart.log");
-  const out = (0, import_node_fs28.openSync)(logPath, "a");
-  const err2 = (0, import_node_fs28.openSync)(logPath, "a");
+  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 portArgs = args.port ? ["--port", String(args.port)] : [];
   const child = (0, import_node_child_process3.spawn)(process.execPath, [entryPath, "serve", ...portArgs], {
     detached: true,
@@ -36338,6 +36928,96 @@ function handleDriftReport(args) {
     items: page
   });
 }
+function handleGenerateSpec(args) {
+  const __resolved = resolveOrErr(args);
+  if ("content" in __resolved) return __resolved;
+  const { rootDir } = __resolved;
+  const target = typeof args.target === "string" ? args.target.trim() : "";
+  if (!target) return err("target is required (a context action node id).");
+  const snippetsDir = typeof args.snippets_dir === "string" && args.snippets_dir.trim() ? args.snippets_dir.trim() : DEFAULT_SNIPPETS_DIR;
+  const specDir = typeof args.spec_dir === "string" && args.spec_dir.trim() ? args.spec_dir.trim() : "tests/generated";
+  const fixtures = args.fixtures && typeof args.fixtures === "object" ? args.fixtures : {};
+  const title = typeof args.title === "string" ? args.title : void 0;
+  const g = readGraph(rootDir, "context");
+  if (!g) return err("No `context` layer found. Run generate_graph first to build context.json.");
+  let node = g.nodes.find((n) => n.id === target);
+  if (!node && !target.startsWith("action:") && !target.startsWith("state:")) {
+    node = g.nodes.find((n) => n.id === `action:${target}`) ?? g.nodes.find((n) => n.id === `state:${target}`);
+  }
+  if (!node) return err(`No context node matching "${target}". Use read_graph layer:context to list nodes.`);
+  const snippets = loadSnippetIndex(rootDir, snippetsDir);
+  const plan = buildTestPlan(g, node.id, snippets);
+  const spec = generateSpec(plan, { title: title ?? String(node.name), specDir, fixtures });
+  return okJson({
+    target: node.id,
+    spec_dir: specDir,
+    suggested_path: `${specDir}/${String(node.name).replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "") || "spec"}.spec.ts`,
+    complete: spec.complete,
+    missing_fixtures: spec.missingFixtures,
+    plan_gaps: plan.gaps,
+    code: spec.code,
+    next: spec.complete ? "Write `code` to suggested_path and run `playwright test` (needs @faker-js/faker installed + the secret env vars set)." : "Supply `fixtures` for missing_fixtures (real seeded values), then regenerate."
+  });
+}
+function handleTestPlan(args) {
+  const __resolved = resolveOrErr(args);
+  if ("content" in __resolved) return __resolved;
+  const { rootDir } = __resolved;
+  const target = typeof args.target === "string" ? args.target.trim() : "";
+  if (!target) return err("target is required (a context action node id).");
+  const snippetsDir = typeof args.snippets_dir === "string" && args.snippets_dir.trim() ? args.snippets_dir.trim() : DEFAULT_SNIPPETS_DIR;
+  const g = readGraph(rootDir, "context");
+  if (!g) return err("No `context` layer found. Run generate_graph first to build context.json.");
+  let node = g.nodes.find((n) => n.id === target);
+  if (!node && !target.startsWith("action:") && !target.startsWith("state:")) {
+    node = g.nodes.find((n) => n.id === `action:${target}`) ?? g.nodes.find((n) => n.id === `state:${target}`);
+  }
+  if (!node) return err(`No context node matching "${target}". Use read_graph layer:context to list nodes.`);
+  const snippets = loadSnippetIndex(rootDir, snippetsDir);
+  const plan = buildTestPlan(g, node.id, snippets);
+  return okJson({
+    ...plan,
+    snippets_dir: snippetsDir,
+    snippets_found: snippets.size,
+    next: plan.runnable ? "Runnable: execute the snippets in `steps` order, threading produced state forward." : "Not yet runnable \u2014 resolve `gaps` (scaffold_snippet for missing bindings; add a producer for unmet states)."
+  });
+}
+function handleScaffoldSnippet(args) {
+  const __resolved = resolveOrErr(args);
+  if ("content" in __resolved) return __resolved;
+  const { rootDir } = __resolved;
+  const target = typeof args.target === "string" ? args.target.trim() : "";
+  if (!target) return err('target is required (a context node id, e.g. "action:app/api/.../tags/route.ts").');
+  const g = readGraph(rootDir, "context");
+  if (!g) return err("No `context` layer found. Run generate_graph first to build context.json.");
+  let node = g.nodes.find((n) => n.id === target);
+  if (!node && !target.startsWith("action:") && !target.startsWith("state:")) {
+    node = g.nodes.find((n) => n.id === `action:${target}`) ?? g.nodes.find((n) => n.id === `state:${target}`);
+  }
+  if (!node) return err(`No context node matching "${target}". Use read_graph layer:context to list nodes.`);
+  const out = g.edges.filter((e) => e.source === node.id);
+  const tokensOf = (type) => [...new Set(out.filter((e) => e.type === type).map((e) => String(e.target).replace(/^state:/, "")))].sort();
+  const requires = tokensOf("requires");
+  const produces = tokensOf("produces");
+  const { exportName, code } = scaffoldSnippet({
+    nodeId: node.id,
+    name: String(node.name ?? node.id),
+    requires,
+    produces
+  });
+  const requiresDetail = out.filter((e) => e.type === "requires").map((e) => ({ state: String(e.target).replace(/^state:/, ""), confidence: e.confidence ?? "low", origin: e.origin ?? null }));
+  return okJson({
+    target: node.id,
+    name: node.name ?? node.id,
+    requires,
+    produces,
+    requires_detail: requiresDetail,
+    export_name: exportName,
+    suggested_path: `tests/snippets/${exportName}.ts`,
+    snippet: code,
+    next: "Fill `params` from the endpoint request/validation schema and implement run() with Playwright, then write the file to suggested_path."
+  });
+}
 function handleWhoUses(args) {
   const __resolved = resolveOrErr(args);
   if ("content" in __resolved) return __resolved;
@@ -36583,20 +37263,20 @@ function handleDetectProjectStack() {
       if (ref.type === "references_api") stats.references_api++;
     }
   }
-  const srcDir = (0, import_node_path33.join)(rootDir, "src");
-  if ((0, import_node_fs28.existsSync)(srcDir)) {
+  const srcDir = (0, import_node_path38.join)(rootDir, "src");
+  if ((0, import_node_fs30.existsSync)(srcDir)) {
     const scanDir = (dir) => {
-      if (!(0, import_node_fs28.existsSync)(dir)) return;
-      for (const entry of (0, import_node_fs28.readdirSync)(dir, { withFileTypes: true })) {
+      if (!(0, import_node_fs30.existsSync)(dir)) return;
+      for (const entry of (0, import_node_fs30.readdirSync)(dir, { withFileTypes: true })) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        const full = (0, import_node_path33.join)(dir, entry.name);
+        const full = (0, import_node_path38.join)(dir, entry.name);
         if (entry.isDirectory()) {
           scanDir(full);
           continue;
         }
-        if (![".ts", ".tsx"].includes((0, import_node_path33.extname)(entry.name))) continue;
+        if (![".ts", ".tsx"].includes((0, import_node_path38.extname)(entry.name))) continue;
         try {
-          const content = (0, import_node_fs28.readFileSync)(full, "utf-8");
+          const content = (0, import_node_fs30.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 {
@@ -36615,7 +37295,7 @@ function handleDetectProjectStack() {
     name: p.name,
     root: p.root,
     absolute_root: p.absoluteRoot,
-    has_graph: (0, import_node_fs28.existsSync)((0, import_node_path33.join)(p.absoluteRoot, LAUNCHSECURE_DIR, "graphs"))
+    has_graph: (0, import_node_fs30.existsSync)((0, import_node_path38.join)(p.absoluteRoot, LAUNCHSECURE_DIR, "graphs"))
   }));
   return okJson({
     languages,
@@ -36745,6 +37425,18 @@ async function handleMessage(msg) {
       respond(id ?? null, withFreshnessMeta(handleWhoUses(args), args));
       return;
     }
+    if (toolName === "scaffold_snippet") {
+      respond(id ?? null, withFreshnessMeta(handleScaffoldSnippet(args), args));
+      return;
+    }
+    if (toolName === "test_plan") {
+      respond(id ?? null, withFreshnessMeta(handleTestPlan(args), args));
+      return;
+    }
+    if (toolName === "generate_spec") {
+      respond(id ?? null, withFreshnessMeta(handleGenerateSpec(args), args));
+      return;
+    }
     if (toolName === "trace_path") {
       respond(id ?? null, withFreshnessMeta(handleTracePath(args), args));
       return;
@@ -36932,7 +37624,7 @@ function parseArgs() {
   return { port, token, serverUrl: LAUNCHSECURE_URL, subcommand, course };
 }
 function tryListen(server, port, maxRetries = 10) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let attempts = 0;
     function attempt(p) {
       server.once("error", (err2) => {
@@ -36943,7 +37635,7 @@ function tryListen(server, port, maxRetries = 10) {
           reject(err2);
         }
       });
-      server.listen(p, "127.0.0.1", () => resolve6(p));
+      server.listen(p, "127.0.0.1", () => resolve7(p));
     }
     attempt(port);
   });
@@ -36964,7 +37656,7 @@ function saveCredentials(creds) {
   });
 }
 function verifyToken(serverUrl, token) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const url = new URL("/api/mcp/verify", serverUrl);
     const body = JSON.stringify({ token });
     const mod = url.protocol === "https:" ? import_https.default : import_http.default;
@@ -36979,30 +37671,30 @@ function verifyToken(serverUrl, token) {
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
-          resolve6(JSON.parse(data));
+          resolve7(JSON.parse(data));
         } catch {
-          resolve6({ valid: false, error: "Invalid response from server" });
+          resolve7({ valid: false, error: "Invalid response from server" });
         }
       });
     });
     req.on("error", (err2) => {
-      resolve6({ valid: false, error: `Cannot reach server: ${err2.message}` });
+      resolve7({ valid: false, error: `Cannot reach server: ${err2.message}` });
     });
     req.setTimeout(1e4, () => {
       req.destroy();
-      resolve6({ valid: false, error: "Connection timed out" });
+      resolve7({ valid: false, error: "Connection timed out" });
     });
     req.write(body);
     req.end();
   });
 }
 function httpRequest2(reqUrl, options, body, timeout = 3e4) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const mod = reqUrl.protocol === "https:" ? import_https.default : import_http.default;
     const r = mod.request(reqUrl, options, (resp) => {
       let data = "";
       resp.on("data", (chunk) => data += chunk);
-      resp.on("end", () => resolve6({ status: resp.statusCode || 0, headers: resp.headers, body: data }));
+      resp.on("end", () => resolve7({ status: resp.statusCode || 0, headers: resp.headers, body: data }));
     });
     r.on("error", reject);
     r.setTimeout(timeout, () => {