@launchsecure/launch-kit 0.0.15 → 0.0.17

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

@@ -4774,13 +4774,221 @@ var init_chart_serve = __esm({
   }
 });
 
+// src/server/blast-radius-builder.ts
+function loadDefaults(rootDir) {
+  const filePath = (0, import_node_path20.join)(rootDir, ".launchsecure", "blast-radius-defaults.json");
+  try {
+    if (import_node_fs18.default.existsSync(filePath)) {
+      const raw = import_node_fs18.default.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return FALLBACK_DEFAULTS;
+}
+function generateAcceptance(node, inspect) {
+  const criteria = [];
+  const t = node.type?.toLowerCase() ?? "";
+  if (t === "endpoint" || t === "mcp-tool") {
+    const methods = inspect?.methods ?? [];
+    const path3 = inspect?.path ?? node.id;
+    if (methods.length > 0) {
+      criteria.push(`${methods.join("/")} ${path3} still returns correct responses for authorized users`);
+    } else {
+      criteria.push(`${path3} still responds correctly`);
+    }
+    if (inspect?.auth && inspect.auth.includes("withAuth")) {
+      criteria.push("Authentication and authorization still enforced");
+    }
+    if (inspect?.db_models && inspect.db_models.length > 0) {
+      criteria.push(`DB operations on ${inspect.db_models.join(", ")} still work correctly`);
+    }
+  } else if (t === "page" || t === "component" || t === "layout") {
+    criteria.push(`${node.name} renders without errors`);
+    if (inspect?.stateVars && inspect.stateVars.length > 0) {
+      criteria.push("State management still works correctly");
+    }
+    if (inspect?.elements && inspect.elements.length > 5) {
+      criteria.push("All child components render correctly");
+    }
+  } else if (t === "table" || t === "enum") {
+    criteria.push(`${node.name} schema unchanged or migration applies cleanly`);
+    criteria.push("Existing queries against this table still work");
+  } else if (t === "hook") {
+    criteria.push(`${node.name} returns expected shape`);
+    if (inspect?.stateVars && inspect.stateVars.length > 0) {
+      criteria.push(`State variables [${inspect.stateVars.map((s) => s.name).join(", ")}] still returned`);
+    }
+  } else if (t === "context") {
+    criteria.push(`${node.name} provides correct context to consumers`);
+  } else if (t === "lib" || t === "config" || t === "types") {
+    criteria.push(`${node.name} exports still conform to expected interface`);
+  } else if (t === "seed" || t === "seed_role" || t === "seed_permission") {
+    criteria.push("Seed runs without errors");
+    criteria.push("Expected rows created in database");
+  } else {
+    criteria.push("Verify no regression");
+  }
+  return criteria;
+}
+function buildManifest(input) {
+  const { mode, title, description, subtitle, blastResults, createNodes, inspectData, defaults } = input;
+  const nodeMap = /* @__PURE__ */ new Map();
+  const centerNodeIds = /* @__PURE__ */ new Set();
+  for (const result of blastResults) {
+    centerNodeIds.add(result.center.id);
+    for (const node of result.affected) {
+      const existing = nodeMap.get(node.id);
+      if (!existing || node.hop < existing.hop) {
+        nodeMap.set(node.id, node);
+      }
+    }
+  }
+  for (const id of centerNodeIds) {
+    nodeMap.delete(id);
+  }
+  const manifestNodes = [];
+  for (const result of blastResults) {
+    const c = result.center;
+    if (manifestNodes.some((n) => n.id === c.id)) continue;
+    const inspect = inspectData[c.id];
+    manifestNodes.push({
+      id: c.id,
+      name: c.name,
+      layer: c.layer,
+      ring: "modify",
+      type: c.type,
+      reason: `Direct change target`,
+      acceptance: generateAcceptance(
+        { id: c.id, name: c.name, type: c.type, layer: c.layer, hop: 0 },
+        inspect
+      )
+    });
+  }
+  for (const [, node] of nodeMap) {
+    const ring = node.hop <= 1 ? "modify" : "ripple";
+    const inspect = inspectData[node.id];
+    const reason = node.hop <= 1 ? `Directly depends on changed node` : `Indirect dependency (${node.hop} hops away)`;
+    manifestNodes.push({
+      id: node.id,
+      name: node.name,
+      layer: node.layer,
+      ring,
+      type: node.type,
+      reason,
+      acceptance: generateAcceptance(node, inspect)
+    });
+  }
+  for (const cn of createNodes) {
+    manifestNodes.push({
+      id: cn.id,
+      name: cn.name,
+      layer: cn.layer,
+      ring: "create",
+      type: cn.type ?? "unknown",
+      reason: cn.reason,
+      acceptance: cn.acceptance ?? ["Verify implementation matches spec"]
+    });
+  }
+  const layerIds = /* @__PURE__ */ new Set();
+  for (const n of manifestNodes) {
+    layerIds.add(n.layer);
+  }
+  const layers = [];
+  for (const id of layerIds) {
+    const def = defaults.layers[id];
+    if (def) {
+      layers.push({ id, name: def.name, icon: def.icon, color: def.color });
+    } else {
+      layers.push({ id, name: id, icon: "box", color: "#cbd5e1" });
+    }
+  }
+  const edgeSet = /* @__PURE__ */ new Set();
+  const edges = [];
+  const allNodeIds = new Set(manifestNodes.map((n) => n.id));
+  for (const cId of centerNodeIds) {
+    for (const result of blastResults) {
+      for (const affected of result.affected) {
+        if (affected.hop === 1 && result.center.id === cId && allNodeIds.has(affected.id)) {
+          const key = `${cId}->${affected.id}`;
+          if (!edgeSet.has(key)) {
+            edgeSet.add(key);
+            edges.push({ source: cId, target: affected.id });
+          }
+        }
+      }
+    }
+  }
+  for (const result of blastResults) {
+    if (result.edges) {
+      for (const edge of result.edges) {
+        if (allNodeIds.has(edge.source) && allNodeIds.has(edge.target)) {
+          const key = `${edge.source}->${edge.target}`;
+          if (!edgeSet.has(key)) {
+            edgeSet.add(key);
+            edges.push({ source: edge.source, target: edge.target });
+          }
+        }
+      }
+    }
+  }
+  for (const cn of createNodes) {
+    edges.push({ source: "center", target: cn.id });
+    if (cn.connects_to) {
+      for (const targetId of cn.connects_to) {
+        if (allNodeIds.has(targetId) || createNodes.some((c) => c.id === targetId)) {
+          const key = `${cn.id}->${targetId}`;
+          if (!edgeSet.has(key)) {
+            edgeSet.add(key);
+            edges.push({ source: cn.id, target: targetId });
+          }
+        }
+      }
+    }
+  }
+  return {
+    mode,
+    title,
+    subtitle,
+    layers,
+    rings: defaults.rings,
+    center: { name: title, description },
+    nodes: manifestNodes,
+    edges
+  };
+}
+var import_node_fs18, import_node_path20, FALLBACK_DEFAULTS;
+var init_blast_radius_builder = __esm({
+  "src/server/blast-radius-builder.ts"() {
+    "use strict";
+    import_node_fs18 = __toESM(require("node:fs"));
+    import_node_path20 = require("node:path");
+    FALLBACK_DEFAULTS = {
+      rings: [
+        { id: "modify", name: "Modify", color: "#ff6b00" },
+        { id: "ripple", name: "Ripple (verify)", color: "#ffff00" },
+        { id: "create", name: "Create", color: "#00ff00" }
+      ],
+      layers: {
+        db: { name: "Database", icon: "database", color: "#cbd5e1" },
+        api: { name: "API", icon: "server", color: "#cbd5e1" },
+        middleware: { name: "Middleware", icon: "shield", color: "#cbd5e1" },
+        ui: { name: "UI", icon: "layout-dashboard", color: "#cbd5e1" },
+        config: { name: "Config / Seed", icon: "settings", color: "#cbd5e1" },
+        shared: { name: "Shared Types", icon: "box", color: "#cbd5e1" }
+      },
+      center: { color: "#ff0000" }
+    };
+  }
+});
+
 // src/server/graph/core/language-detection.ts
 function walkForExtensions(dir, extCounts, depth = 0) {
   if (depth > 10) return;
-  if (!(0, import_node_fs18.existsSync)(dir)) return;
+  if (!(0, import_node_fs19.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true });
+    entries = (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -4788,9 +4996,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_path20.join)(dir, entry.name), extCounts, depth + 1);
+      walkForExtensions((0, import_node_path21.join)(dir, entry.name), extCounts, depth + 1);
     } else {
-      const ext = (0, import_node_path20.extname)(entry.name).toLowerCase();
+      const ext = (0, import_node_path21.extname)(entry.name).toLowerCase();
       if (ext && EXTENSION_TO_LANGUAGE[ext]) {
         extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
       }
@@ -4829,12 +5037,12 @@ function detectLanguages(rootDir, supportedLanguages) {
   });
   return results;
 }
-var import_node_fs18, import_node_path20, EXTENSION_TO_LANGUAGE, IGNORE_DIRS, AUXILIARY_LANGUAGES;
+var import_node_fs19, import_node_path21, EXTENSION_TO_LANGUAGE, IGNORE_DIRS, AUXILIARY_LANGUAGES;
 var init_language_detection = __esm({
   "src/server/graph/core/language-detection.ts"() {
     "use strict";
-    import_node_fs18 = require("node:fs");
-    import_node_path20 = require("node:path");
+    import_node_fs19 = require("node:fs");
+    import_node_path21 = require("node:path");
     EXTENSION_TO_LANGUAGE = {
       // Web / Frontend
       ".ts": "typescript",
@@ -5167,6 +5375,144 @@ function handleBlastPoints(args) {
     }
   });
 }
+function handleGenerateBlastRadius(args) {
+  const rootDir = process.cwd();
+  const mode = args.mode ?? "structural";
+  const title = args.title;
+  const description = args.description ?? title;
+  const subtitle = args.subtitle;
+  const hops = args.hops ?? 2;
+  const defaults = loadDefaults(rootDir);
+  let centerNodeIds = [];
+  if (mode === "structural") {
+    const nodeId = args.node_id;
+    if (!nodeId) return err("structural mode requires node_id");
+    centerNodeIds = [nodeId];
+  } else {
+    centerNodeIds = args.center_nodes ?? [];
+    if (centerNodeIds.length === 0) return err("feature mode requires center_nodes[]");
+  }
+  const createNodes = args.create_nodes ?? [];
+  const blastResults = [];
+  for (const nodeId of centerNodeIds) {
+    let targetLayer;
+    const graphs = readAllGraphs(rootDir);
+    for (const [layer, graph2] of Object.entries(graphs)) {
+      if (graph2 && graph2.nodes.some((n) => n.id === nodeId)) {
+        targetLayer = layer;
+        break;
+      }
+    }
+    if (!targetLayer) continue;
+    const graph = readGraph(rootDir, targetLayer);
+    if (!graph) continue;
+    const center = graph.nodes.find((n) => n.id === nodeId);
+    if (!center) continue;
+    const result2 = reverseNeighborhood(graph, nodeId, hops, "reverse");
+    const affected = [];
+    for (const [id, { node, hop }] of result2.nodes) {
+      if (id === nodeId) continue;
+      const tags = node.tags;
+      affected.push({ id: node.id, name: node.name, type: node.type, layer: targetLayer, hop, module: tags?.module });
+    }
+    const otherLayers = getAvailableLayers(rootDir).filter((l) => l !== targetLayer && l !== "static");
+    for (const otherLayer of otherLayers) {
+      const otherGraph = readGraph(rootDir, otherLayer);
+      if (!otherGraph) continue;
+      for (const edge of otherGraph.edges) {
+        if (edge.target === nodeId || edge.source === nodeId) {
+          const dependentId = edge.target === nodeId ? edge.source : edge.target;
+          if (affected.some((a) => a.id === dependentId)) continue;
+          const depNode = otherGraph.nodes.find((n) => n.id === dependentId);
+          if (depNode) {
+            const tags = depNode.tags;
+            affected.push({ id: depNode.id, name: depNode.name, type: depNode.type, layer: otherLayer, hop: 1, module: tags?.module });
+          }
+        }
+      }
+    }
+    const centerTags = center.tags;
+    const edges = result2.edges.map((e) => ({ source: e.source, target: e.target }));
+    blastResults.push({
+      center: { id: center.id, name: center.name, type: center.type, layer: targetLayer, module: centerTags?.module },
+      affected,
+      edges
+    });
+  }
+  if (blastResults.length === 0) {
+    return err(`None of the center nodes were found in any graph layer: ${centerNodeIds.join(", ")}`);
+  }
+  const inspectData = {};
+  const allAffectedIds = /* @__PURE__ */ new Set();
+  for (const r of blastResults) {
+    allAffectedIds.add(r.center.id);
+    for (const a of r.affected) allAffectedIds.add(a.id);
+  }
+  const allGraphs = readAllGraphs(rootDir);
+  for (const id of allAffectedIds) {
+    for (const [, graph] of Object.entries(allGraphs)) {
+      if (!graph) continue;
+      const node = graph.nodes.find((n) => n.id === id);
+      if (node) {
+        inspectData[id] = {
+          type: node.type,
+          name: node.name,
+          methods: node.methods,
+          path: node.path ?? node.handler,
+          auth: node.auth,
+          db_models: node.db_models
+        };
+        break;
+      }
+    }
+  }
+  const manifest = buildManifest({
+    mode,
+    title,
+    description,
+    subtitle,
+    blastResults,
+    createNodes,
+    inspectData,
+    defaults
+  });
+  const pushToDeck = args.push_to_deck;
+  const session = args.session;
+  let deckResult;
+  if (pushToDeck) {
+    if (!session) return err("push_to_deck requires a session name");
+    const deckLockPath = (0, import_node_path22.join)(rootDir, ".launchsecure", "launch-deck.lock");
+    if (!(0, import_node_fs20.existsSync)(deckLockPath)) {
+      deckResult = { pushed: false, reason: "Deck server not running (no lock file). Push manually via deck tool." };
+    } else {
+      try {
+        const lock = JSON.parse((0, import_node_fs20.readFileSync)(deckLockPath, "utf-8"));
+        const deckUrl = lock.url;
+        const body = JSON.stringify({
+          session,
+          mode: "show",
+          blocks: [{ type: "blast-radius", label: title, manifest }]
+        });
+        (0, import_node_child_process2.execFileSync)("curl", [
+          "-s",
+          "-X",
+          "POST",
+          deckUrl + "/api/deck",
+          "-H",
+          "Content-Type: application/json",
+          "-d",
+          body
+        ], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] });
+        deckResult = { pushed: true, session, url: deckUrl };
+      } catch (e) {
+        deckResult = { pushed: false, reason: `Failed to push to deck: ${e}` };
+      }
+    }
+  }
+  const result = { ...manifest };
+  if (deckResult) result._deck = deckResult;
+  return okJson(result);
+}
 function layerSummary(graph) {
   const typeCounts = {};
   const moduleCounts = {};
@@ -5395,12 +5741,12 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui" || layer === "api") return (0, import_node_path21.join)(rootDir, "src", nodeId);
-  if (layer === "db") return (0, import_node_path21.join)(rootDir, "prisma", "schema.prisma");
-  const withSrc = (0, import_node_path21.join)(rootDir, "src", nodeId);
-  if ((0, import_node_fs19.existsSync)(withSrc)) return withSrc;
-  const direct = (0, import_node_path21.join)(rootDir, nodeId);
-  if ((0, import_node_fs19.existsSync)(direct)) return direct;
+  if (layer === "ui" || layer === "api") return (0, import_node_path22.join)(rootDir, "src", nodeId);
+  if (layer === "db") return (0, import_node_path22.join)(rootDir, "prisma", "schema.prisma");
+  const withSrc = (0, import_node_path22.join)(rootDir, "src", nodeId);
+  if ((0, import_node_fs20.existsSync)(withSrc)) return withSrc;
+  const direct = (0, import_node_path22.join)(rootDir, nodeId);
+  if ((0, import_node_fs20.existsSync)(direct)) return direct;
   return null;
 }
 function handleInspectNode(args) {
@@ -5543,11 +5889,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs19.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs20.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs19.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs20.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -5612,11 +5958,11 @@ function handleStartChartServer(args) {
     });
   }
   const entryPath = process.argv[1];
-  const logDir = (0, import_node_path21.join)((0, import_node_os2.homedir)(), ".launchsecure");
-  (0, import_node_fs19.mkdirSync)(logDir, { recursive: true });
-  const logPath = (0, import_node_path21.join)(logDir, "launch-chart.log");
-  const out = (0, import_node_fs19.openSync)(logPath, "a");
-  const err2 = (0, import_node_fs19.openSync)(logPath, "a");
+  const logDir = (0, import_node_path22.join)((0, import_node_os2.homedir)(), ".launchsecure");
+  (0, import_node_fs20.mkdirSync)(logDir, { recursive: true });
+  const logPath = (0, import_node_path22.join)(logDir, "launch-chart.log");
+  const out = (0, import_node_fs20.openSync)(logPath, "a");
+  const err2 = (0, import_node_fs20.openSync)(logPath, "a");
   const portArgs = args.port ? ["--port", String(args.port)] : [];
   const child = (0, import_node_child_process2.spawn)(process.execPath, [entryPath, "serve", ...portArgs], {
     detached: true,
@@ -5736,20 +6082,20 @@ function handleDetectProjectStack() {
       if (ref.type === "references_api") stats.references_api++;
     }
   }
-  const srcDir = (0, import_node_path21.join)(rootDir, "src");
-  if ((0, import_node_fs19.existsSync)(srcDir)) {
+  const srcDir = (0, import_node_path22.join)(rootDir, "src");
+  if ((0, import_node_fs20.existsSync)(srcDir)) {
     const scanDir = (dir) => {
-      if (!(0, import_node_fs19.existsSync)(dir)) return;
-      for (const entry of (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true })) {
+      if (!(0, import_node_fs20.existsSync)(dir)) return;
+      for (const entry of (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true })) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        const full = (0, import_node_path21.join)(dir, entry.name);
+        const full = (0, import_node_path22.join)(dir, entry.name);
         if (entry.isDirectory()) {
           scanDir(full);
           continue;
         }
-        if (![".ts", ".tsx"].includes((0, import_node_path21.extname)(entry.name))) continue;
+        if (![".ts", ".tsx"].includes((0, import_node_path22.extname)(entry.name))) continue;
         try {
-          const content = (0, import_node_fs19.readFileSync)(full, "utf-8");
+          const content = (0, import_node_fs20.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 {
@@ -5868,6 +6214,10 @@ async function handleMessage(msg) {
       respond(id ?? null, handleBlastPoints(args));
       return;
     }
+    if (toolName === "generate_blast_radius") {
+      respond(id ?? null, handleGenerateBlastRadius(args));
+      return;
+    }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
     return;
   }
@@ -5903,15 +6253,16 @@ function startGraphMcpServer() {
   process.stderr.write(`[launchsecure-graph] MCP server started (cwd: ${process.cwd()})
 `);
 }
-var import_node_fs19, import_node_path21, import_node_child_process2, import_node_os2, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, DEEP_FIELDS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, DEFAULT_EST_NODE_FULL, DEFAULT_EST_NODE_MIN, DEFAULT_EST_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
+var import_node_fs20, import_node_path22, import_node_child_process2, import_node_os2, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, DEEP_FIELDS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, DEFAULT_EST_NODE_FULL, DEFAULT_EST_NODE_MIN, DEFAULT_EST_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
 var init_graph_mcp = __esm({
   "src/server/graph-mcp.ts"() {
     "use strict";
-    import_node_fs19 = require("node:fs");
-    import_node_path21 = require("node:path");
+    import_node_fs20 = require("node:fs");
+    import_node_path22 = require("node:path");
     import_node_child_process2 = require("node:child_process");
     import_node_os2 = require("node:os");
     init_graph();
+    init_blast_radius_builder();
     init_lockfile();
     init_config();
     init_parser_registry();
@@ -6228,6 +6579,81 @@ Example: blast_points(node_id: "server/auth/middleware.ts", hops: 2) \u2192 retu
           },
           required: ["node_id"]
         }
+      },
+      {
+        name: "generate_blast_radius",
+        description: `Generate a complete BlastRadiusManifest from graph data \u2014 ready to push to deck.
+
+Two modes:
+- **Structural**: single node changed \u2192 auto-discover what's affected via reverse BFS
+  Example: generate_blast_radius({ mode: "structural", node_id: "CommentChannel", title: "CommentChannel refactor" })
+- **Feature**: new feature \u2192 multiple starting nodes + new nodes to create
+  Example: generate_blast_radius({ mode: "feature", title: "Client Role", description: "...", center_nodes: ["CommentChannel", "ProjectMember"], create_nodes: [{ id: "ChannelMember", name: "ChannelMember table", layer: "db", reason: "..." }] })
+
+Output is a BlastRadiusManifest JSON that passes directly to the deck tool's blast-radius block.
+Reads ring/layer/center colors from .launchsecure/blast-radius-defaults.json.
+Auto-generates acceptance criteria per node using inspect_node AST data.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              enum: ["structural", "feature"],
+              description: '"structural" = single node changed. "feature" = new feature with multiple nodes.'
+            },
+            title: {
+              type: "string",
+              description: "Title for the blast radius (shown in center node and header)."
+            },
+            description: {
+              type: "string",
+              description: "Description of the change or feature."
+            },
+            subtitle: {
+              type: "string",
+              description: "Optional subtitle shown above title in the viz."
+            },
+            node_id: {
+              type: "string",
+              description: "Structural mode only: the node being changed."
+            },
+            center_nodes: {
+              type: "array",
+              items: { type: "string" },
+              description: "Feature mode: existing graph node IDs that are the starting points for traversal."
+            },
+            create_nodes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  name: { type: "string" },
+                  layer: { type: "string" },
+                  type: { type: "string" },
+                  reason: { type: "string" },
+                  acceptance: { type: "array", items: { type: "string" } },
+                  connects_to: { type: "array", items: { type: "string" }, description: "IDs of existing nodes this new node has FK/relationship edges to." }
+                },
+                required: ["id", "name", "layer", "reason"]
+              },
+              description: "Feature mode: new nodes that need to be created (not in graph yet)."
+            },
+            hops: {
+              type: "number",
+              description: "Max hops for traversal. Default 2. Hop 1 = modify ring, hop 2+ = ripple ring."
+            },
+            push_to_deck: {
+              type: "boolean",
+              description: "If true, pushes the manifest directly to LaunchDeck browser (requires deck server running). Default false."
+            },
+            session: {
+              type: "string",
+              description: "Session name for the deck tab. Required when push_to_deck is true."
+            }
+          },
+          required: ["title"]
+        }
       }
     ];
     COMPACT_SCHEMA = {
@@ -6294,10 +6720,10 @@ Example: blast_points(node_id: "server/auth/middleware.ts", hops: 2) \u2192 retu
 
 // src/server/graph-mcp-entry.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs20 = require("node:fs");
-var import_node_path22 = __toESM(require("node:path"));
-var import_node_os3 = require("node:os");
 var import_node_fs21 = require("node:fs");
+var import_node_path23 = __toESM(require("node:path"));
+var import_node_os3 = require("node:os");
+var import_node_fs22 = require("node:fs");
 init_lockfile();
 function logStderr(msg) {
   process.stderr.write(`[launch-chart] ${msg}
@@ -6313,11 +6739,11 @@ function maybeAutoServe() {
     return;
   }
   try {
-    const logDir = import_node_path22.default.join((0, import_node_os3.homedir)(), ".launchsecure");
-    (0, import_node_fs21.mkdirSync)(logDir, { recursive: true });
-    const logPath = import_node_path22.default.join(logDir, "launch-chart.log");
-    const out = (0, import_node_fs20.openSync)(logPath, "a");
-    const err2 = (0, import_node_fs20.openSync)(logPath, "a");
+    const logDir = import_node_path23.default.join((0, import_node_os3.homedir)(), ".launchsecure");
+    (0, import_node_fs22.mkdirSync)(logDir, { recursive: true });
+    const logPath = import_node_path23.default.join(logDir, "launch-chart.log");
+    const out = (0, import_node_fs21.openSync)(logPath, "a");
+    const err2 = (0, import_node_fs21.openSync)(logPath, "a");
     const entryPath = process.argv[1];
     const child = (0, import_node_child_process3.spawn)(process.execPath, [entryPath, "serve"], {
       detached: true,