@launchsecure/launch-kit 0.0.32 → 0.0.34

package/dist/server/cli.js

@@ -23251,6 +23251,7 @@ function emptyParsedFile(absPath) {
   return {
     name: absPath.split("/").pop() ?? absPath,
     exports: [],
+    defines: [],
     imports: [],
     reExports: [],
     jsxElements: /* @__PURE__ */ new Set(),
@@ -23363,6 +23364,34 @@ function parseFileTS(absPath) {
       reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: true });
     }
   }
+  const definesSet = /* @__PURE__ */ new Set();
+  function recordCallable(decl) {
+    if (decl.type === "function_declaration" || decl.type === "generator_function_declaration") {
+      const id = childOfType(decl, "identifier");
+      if (id) definesSet.add(id.text);
+      return;
+    }
+    if (decl.type === "class_declaration") {
+      const id = childOfType(decl, "type_identifier") ?? childOfType(decl, "identifier");
+      if (id) definesSet.add(id.text);
+      return;
+    }
+    if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
+      for (const d of childrenOfType(decl, "variable_declarator")) {
+        const id = childOfType(d, "identifier");
+        if (!id) continue;
+        const isCallable = !!childOfType(d, "arrow_function") || !!childOfType(d, "function_expression") || !!childOfType(d, "function") || !!childOfType(d, "generator_function");
+        if (isCallable) definesSet.add(id.text);
+      }
+    }
+  }
+  for (const child of root.children) {
+    if (child.type === "export_statement") {
+      for (const gc of child.children) recordCallable(gc);
+    } else {
+      recordCallable(child);
+    }
+  }
   const jsxElements = /* @__PURE__ */ new Set();
   const jsxQuery = getQuery("jsx-elements");
   const jsxCaptures = jsxQuery.captures(root);
@@ -23451,7 +23480,7 @@ function parseFileTS(absPath) {
     }
   }
   const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
-  return { name, exports: exportsOrdered, imports, reExports, jsxElements, navigations, fetchCalls };
+  return { name, exports: exportsOrdered, defines: [...definesSet], imports, reExports, jsxElements, navigations, fetchCalls };
 }
 function extractDbCallsTS(absPath) {
   const tree = parseSource(absPath);
@@ -24542,17 +24571,17 @@ function shutdownTerminalBridge() {
   }
 }
 
-// src/server/launchpod-terminal-init.ts
+// src/server/sequencer-terminal-init.ts
 var import_path = __toESM(require("path"));
 init_launch_kit_paths();
-function initLaunchPodTerminalBridge(httpServer, projectDir) {
+function initSequencerTerminalBridge(httpServer, projectDir) {
   return initTerminalBridge(httpServer, projectDir, import_path.default.join(projectDir, LAUNCHPOD_DIR, "sessions"));
 }
 
 // src/server/mcp-config-writer.ts
 var import_fs = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
-var MANAGED_SERVERS = ["launch-pod", "launch-chart"];
+var MANAGED_SERVERS = ["launch-pod", "launch-sequencer", "launch-chart"];
 function mergeMcpEntry(existing, ours) {
   if (!existing || typeof existing !== "object") return ours;
   const prev = existing;
@@ -24601,7 +24630,7 @@ function removeClaudeEntries(filePath) {
     } else {
       existing.mcpServers = servers;
       import_fs.default.writeFileSync(filePath, JSON.stringify(existing, null, 2) + "\n", { mode: 384 });
-      console.log(`MCP config cleaned (LaunchPod entries removed): ${filePath}`);
+      console.log(`MCP config cleaned (launch-sequencer entries removed): ${filePath}`);
     }
   } catch {
     try {
@@ -24626,7 +24655,8 @@ function writeClaudeConfig(projectDir, mcpUrl, token) {
     }
   }
   const servers = existing.mcpServers ?? {};
-  servers["launch-pod"] = mergeMcpEntry(servers["launch-pod"], {
+  delete servers["launch-pod"];
+  servers["launch-sequencer"] = mergeMcpEntry(servers["launch-sequencer"], {
     type: "http",
     url: mcpUrl,
     headers: {
@@ -24655,9 +24685,9 @@ function writeCodexConfig(projectDir, mcpUrl, token) {
     }
   } catch {
   }
-  const cleaned = existingContent.replace(/\[mcp_servers\.launch-pod\][^\[]*/, "").replace(/\[mcp_servers\.launch-chart\][^\[]*/, "").trim();
-  const launchPodBlock = [
-    `[mcp_servers.launch-pod]`,
+  const cleaned = existingContent.replace(/\[mcp_servers\.launch-pod\][^\[]*/, "").replace(/\[mcp_servers\.launch-sequencer\][^\[]*/, "").replace(/\[mcp_servers\.launch-chart\][^\[]*/, "").trim();
+  const managedBlock = [
+    `[mcp_servers.launch-sequencer]`,
     `url = "${mcpUrl}"`,
     `http_headers = { "Authorization" = "Bearer ${token}" }`,
     ``,
@@ -24665,7 +24695,7 @@ function writeCodexConfig(projectDir, mcpUrl, token) {
     `command = "launch-chart"`,
     `args = []`
   ].join("\n");
-  const merged = cleaned ? cleaned + "\n\n" + launchPodBlock + "\n" : launchPodBlock + "\n";
+  const merged = cleaned ? cleaned + "\n\n" + managedBlock + "\n" : managedBlock + "\n";
   import_fs.default.writeFileSync(filePath, merged, { mode: 384 });
   writtenPaths.push(filePath);
   console.log(`Codex MCP config merged into ${filePath}`);
@@ -28032,7 +28062,7 @@ var RadarState = class {
   }
 };
 
-// src/server/radar/tunnel.ts
+// src/server/tunnel/index.ts
 var import_node_fs3 = require("node:fs");
 var import_node_events = require("node:events");
 var import_promises = require("node:dns/promises");
@@ -28386,7 +28416,7 @@ var CacheableLookup = class {
   }
 };
 
-// src/server/radar/tunnel.ts
+// src/server/tunnel/index.ts
 var import_undici = __toESM(require_undici());
 var import_cloudflared = require("cloudflared");
 var dnsResolver = new import_promises.Resolver();
@@ -28404,14 +28434,42 @@ var BACKOFF_MIN_MS = 1e3;
 var BACKOFF_MAX_MS = 3e5;
 var SELFTEST_INTERVAL_MS = 1e3;
 var SELFTEST_TIMEOUT_MS = 9e4;
+function resolveTunnelMode(opts) {
+  const env = opts.env ?? process.env;
+  const tokenKey = `${opts.varPrefix}_TUNNEL_TOKEN`;
+  const hostKey = `${opts.varPrefix}_TUNNEL_HOSTNAME`;
+  const token = env[tokenKey]?.trim();
+  const hostname = env[hostKey]?.trim()?.replace(/^https?:\/\//, "").replace(/\/$/, "");
+  if (!token && !hostname) return { kind: "quick" };
+  if (!token || !hostname) {
+    const missing = !token ? tokenKey : hostKey;
+    throw new Error(
+      `[tunnel] named-tunnel config is partial \u2014 ${missing} is not set. Set BOTH ${tokenKey} and ${hostKey} for a stable paid tunnel, or unset both to fall back to the free quick tunnel.`
+    );
+  }
+  return { kind: "named", token, hostname };
+}
+var NAMED_FATAL_PATTERNS = [
+  /\bunauthorized\b/i,
+  /\b401\b/,
+  /invalid (tunnel )?token/i,
+  /token (is )?expired/i,
+  /tunnel .{0,80}? not found/i,
+  /failed to (provision|find|authenticate) tunnel/i,
+  /failed to read tunnel credentials/i,
+  /jwt.*expired/i
+];
 var CloudflaredTunnel = class extends import_node_events.EventEmitter {
-  constructor(localPort) {
+  constructor(opts) {
     super();
     this.tunnel = null;
     this.currentUrl = null;
     this.stopping = false;
+    this.fatal = false;
     this.restartAttempt = 0;
-    this.localPort = localPort;
+    this.localPort = opts.localPort;
+    this.mode = opts.mode;
+    this.probePath = opts.probePath;
   }
   get publicUrl() {
     return this.currentUrl;
@@ -28419,7 +28477,7 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
   async start() {
     if (this.tunnel) return;
     if (!(0, import_node_fs3.existsSync)(import_cloudflared.bin)) {
-      console.log("[radar] downloading cloudflared binary (one-time setup)\u2026");
+      console.log("[tunnel] downloading cloudflared binary (one-time setup)\u2026");
       try {
         await (0, import_cloudflared.install)(import_cloudflared.bin);
       } catch (err2) {
@@ -28427,6 +28485,11 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
         throw new Error(`Failed to install cloudflared binary: ${msg}`);
       }
     }
+    if (this.mode.kind === "named") {
+      console.log(`[tunnel] mode=named host=${this.mode.hostname} (paid \xB7 stable URL)`);
+    } else {
+      console.log(`[tunnel] mode=quick (free \xB7 *.trycloudflare.com \xB7 ephemeral URL)`);
+    }
     this.spawnOnce();
   }
   async stop() {
@@ -28447,10 +28510,11 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
     });
   }
   spawnOnce() {
-    const tun = import_cloudflared.Tunnel.quick(`http://127.0.0.1:${this.localPort}`);
+    if (this.fatal) return;
+    const tun = this.mode.kind === "named" ? import_cloudflared.Tunnel.withToken(this.mode.token) : import_cloudflared.Tunnel.quick(`http://127.0.0.1:${this.localPort}`);
     this.tunnel = tun;
     this.currentUrl = null;
-    let urlSeen = null;
+    let urlSeen = this.mode.kind === "named" ? `https://${this.mode.hostname}` : null;
     let connectedSeen = false;
     let announced = false;
     const announceIfReady = () => {
@@ -28460,30 +28524,60 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
       void this.selfTestAndAnnounce(url);
     };
     tun.on("url", (url) => {
+      if (this.mode.kind === "named") return;
       if (urlSeen === url) return;
       urlSeen = url;
-      console.log(`[radar] tunnel subdomain assigned: ${url} (waiting for edge connection)`);
+      console.log(`[tunnel] subdomain assigned: ${url} (waiting for edge connection)`);
       announceIfReady();
     });
     tun.on("connected", (conn) => {
       if (!connectedSeen) {
         connectedSeen = true;
-        console.log(`[radar] tunnel connected to edge: ${conn?.location ?? "?"} (${conn?.id ?? "?"})`);
+        console.log(`[tunnel] connected to edge: ${conn?.location ?? "?"} (${conn?.id ?? "?"})`);
       }
       announceIfReady();
     });
+    if (this.mode.kind === "named") {
+      tun.on("stderr", (line) => {
+        if (this.fatal) return;
+        for (const pat of NAMED_FATAL_PATTERNS) {
+          if (pat.test(line)) {
+            this.markFatal(`cloudflared rejected the named-tunnel config \u2014 ${line.trim().slice(0, 200)}`);
+            return;
+          }
+        }
+      });
+    }
     tun.on("error", (err2) => {
       if (this.stopping) return;
-      console.error(`[radar] cloudflared error: ${err2.message}`);
+      console.error(`[tunnel] cloudflared error: ${err2.message}`);
     });
     tun.on("exit", (code) => {
       if (this.stopping) return;
       this.tunnel = null;
       this.currentUrl = null;
+      if (this.fatal) return;
       this.emit("crashed", code);
       this.scheduleRestart();
     });
   }
+  /**
+   * Mark the tunnel fatally broken. Suppresses restart-on-crash and notifies
+   * the parent so it can surface status=error to the UI. Named-mode only —
+   * quick mode has no auth surface to fail on.
+   */
+  markFatal(reason) {
+    if (this.fatal) return;
+    this.fatal = true;
+    this.stopping = true;
+    console.error(`[tunnel] FATAL: ${reason}`);
+    console.error(`[tunnel] not falling back to free tunnel \u2014 fix the named-tunnel env vars (or unset both) and restart.`);
+    this.emit("fatal", reason);
+    try {
+      this.tunnel?.stop();
+    } catch {
+    }
+  }
   /**
    * Poll the public URL until any HTTP response comes back (proving DNS +
    * edge + tunnel work end-to-end), then announce ready. Network errors are
@@ -28491,7 +28585,7 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
    * we log loudly but keep cloudflared alive so a later retry can succeed.
    */
   async selfTestAndAnnounce(url) {
-    const probeUrl = `${url}/api/radar/ingest`;
+    const probeUrl = `${url}${this.probePath}`;
     const started = Date.now();
     let attempts = 0;
     while (Date.now() - started < SELFTEST_TIMEOUT_MS) {
@@ -28503,7 +28597,7 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
           signal: AbortSignal.timeout(5e3),
           dispatcher: dnsResilientDispatcher
         });
-        console.log(`[radar] self-test ok (${res.status}) after ${attempts} attempt(s)`);
+        console.log(`[tunnel] self-test ok (${res.status}) after ${attempts} attempt(s)`);
         this.currentUrl = url;
         this.restartAttempt = 0;
         this.emit("ready", url);
@@ -28511,26 +28605,42 @@ var CloudflaredTunnel = class extends import_node_events.EventEmitter {
       } catch (err2) {
         if (attempts === 1 || attempts % 10 === 0) {
           const msg = err2 instanceof Error ? err2.message : String(err2);
-          console.log(`[radar] self-test attempt ${attempts}: ${msg} \u2014 retrying`);
+          console.log(`[tunnel] self-test attempt ${attempts}: ${msg} \u2014 retrying`);
         }
         await new Promise((r) => setTimeout(r, SELFTEST_INTERVAL_MS));
       }
     }
-    console.error(`[radar] self-test gave up after ${Math.round(SELFTEST_TIMEOUT_MS / 1e3)}s \u2014 tunnel announced but unreachable from this host`);
+    console.error(`[tunnel] self-test gave up after ${Math.round(SELFTEST_TIMEOUT_MS / 1e3)}s \u2014 tunnel announced but unreachable from this host`);
   }
   scheduleRestart() {
     if (this.stopping) return;
     this.restartAttempt += 1;
     const delay = Math.min(BACKOFF_MIN_MS * 2 ** (this.restartAttempt - 1), BACKOFF_MAX_MS);
-    console.log(`[radar] tunnel down \u2014 restarting in ${Math.round(delay / 1e3)}s (attempt ${this.restartAttempt})`);
+    console.log(`[tunnel] down \u2014 restarting in ${Math.round(delay / 1e3)}s (attempt ${this.restartAttempt})`);
     setTimeout(() => this.spawnOnce(), delay);
   }
 };
+function createTunnel(opts) {
+  if (opts.provider === null) return null;
+  if (opts.provider === "cloudflare") {
+    if (!opts.varPrefix) {
+      throw new Error(`[tunnel] createTunnel({ provider: "cloudflare" }) requires varPrefix`);
+    }
+    const mode = resolveTunnelMode({ varPrefix: opts.varPrefix, env: opts.env });
+    return new CloudflaredTunnel({
+      localPort: opts.localPort,
+      mode,
+      probePath: opts.probePath
+    });
+  }
+  const exhaustive = opts.provider;
+  throw new Error(`[tunnel] unknown provider: ${String(exhaustive)}`);
+}
 
 // src/server/radar/agent.ts
 var SLOT_RELEASE_MS = 15 * 60 * 1e3;
 var AUTO_RESUME_STALENESS_MS = 60 * 60 * 1e3;
-var Radar = class {
+var Radar = class _Radar {
   constructor(opts) {
     this.wss = null;
     this.clients = /* @__PURE__ */ new Set();
@@ -28555,7 +28665,18 @@ var Radar = class {
       orgSlug: opts.orgSlug,
       projectSlug: opts.projectSlug
     });
-    this.tunnel = new CloudflaredTunnel(opts.localPort);
+    const tunnel = createTunnel({
+      provider: _Radar.TUNNEL_PROVIDER,
+      localPort: opts.localPort,
+      probePath: RECEIVER_PATH,
+      varPrefix: "RADAR_CF"
+    });
+    if (!tunnel) {
+      throw new Error(
+        `[radar] tunnel provider "${_Radar.TUNNEL_PROVIDER}" produced no tunnel \u2014 radar requires a public URL to register its receiver webhook.`
+      );
+    }
+    this.tunnel = tunnel;
     this.maxConcurrent = parsePositiveInt(process.env.RADAR_MAX_CONCURRENT_ANALYSES);
     const callbacks = {
       onLive: () => this.handleLive(),
@@ -28567,6 +28688,13 @@ var Radar = class {
     };
     this.receiver = createReceiver({ state: this.state, callbacks });
   }
+  static {
+    // Tunnel provider is hardcoded for now — radar today cannot function
+    // without a public URL (it has to register the receiver as a webhook with
+    // LaunchSecure). If a future story wants radar to run behind a pre-existing
+    // public hostname, add a "none" branch with a RADAR_PUBLIC_URL escape hatch.
+    this.TUNNEL_PROVIDER = "cloudflare";
+  }
   /** Spawn tunnel, register (or refresh) the webhook, wait for activation. */
   start() {
     this.status = "tunneling";
@@ -28577,6 +28705,11 @@ var Radar = class {
     this.tunnel.on("crashed", (code) => {
       console.error(`[radar] tunnel exited (code=${code ?? "?"}) \u2014 restarting`);
     });
+    this.tunnel.on("fatal", (reason) => {
+      this.status = "error";
+      console.error(`[radar] named tunnel halted: ${reason}`);
+      this.broadcastStatus();
+    });
     void this.tunnel.start();
     this.autoResumeRecentlyInterrupted();
   }
@@ -29805,6 +29938,11 @@ function generate(rootDir) {
     const parsed = parsedByPath.get(absPath);
     const name = parsed.name || nameFromFilename(absPath);
     const layer = CLASSIFICATION_TO_LAYER[type] ?? "ui";
+    const importedNames = [...new Set(
+      parsed.imports.flatMap(
+        (imp) => imp.isTypeOnly ? [] : imp.names.filter((n) => !imp.typeNames.has(n))
+      )
+    )];
     nodeIdSet.add(id);
     if (layer === "api") {
       const dbCalls = extractDbCallsTS(absPath);
@@ -29843,6 +29981,8 @@ function generate(rootDir) {
         responses: deep.responses,
         params: deep.params,
         ...deep.effects ? { effects: deep.effects } : {},
+        ...parsed.defines.length > 0 ? { defines: parsed.defines } : {},
+        ...importedNames.length > 0 ? { imported_names: importedNames } : {},
         ...deep.notes ? { notes: deep.notes } : {},
         _dbCalls: dbCalls
         // temp: used for cross-ref building below
@@ -29859,6 +29999,8 @@ function generate(rootDir) {
         layer: "ui",
         route,
         exports: parsed.exports,
+        ...parsed.defines.length > 0 ? { defines: parsed.defines } : {},
+        ...importedNames.length > 0 ? { imported_names: importedNames } : {},
         elements: deep.elements,
         stateVars: deep.stateVars,
         conditions: deep.conditions,
@@ -32819,6 +32961,132 @@ var middlewareGatesParser = {
   }
 };
 
+// src/server/graph/parsers/crosslayer/call-resolver.ts
+var BARE_IDENT = /^[A-Za-z_$][\w$]*$/;
+var callResolverParser = {
+  id: "call-resolver",
+  layer: "crosslayer",
+  concern: "call-graph",
+  detect(_rootDir) {
+    return true;
+  },
+  generate(_rootDir, layerOutputs) {
+    const definers = /* @__PURE__ */ new Map();
+    const addDef = (sym, entry) => {
+      if (!BARE_IDENT.test(sym)) return;
+      const list = definers.get(sym);
+      if (!list) {
+        definers.set(sym, [entry]);
+      } else if (!list.some((d) => d.nodeId === entry.nodeId)) {
+        list.push(entry);
+      }
+    };
+    const nodeLayer = /* @__PURE__ */ new Map();
+    for (const [layer, output] of layerOutputs) {
+      if (layer === "db" || layer === "static") continue;
+      for (const node of output.nodes) {
+        nodeLayer.set(node.id, layer);
+        const entry = { nodeId: node.id, layer };
+        for (const s of node.exports ?? []) addDef(s, entry);
+        for (const s of node.defines ?? []) addDef(s, entry);
+      }
+    }
+    const importTargets = /* @__PURE__ */ new Map();
+    for (const [, output] of layerOutputs) {
+      for (const e of output.edges) {
+        if (e.type !== "imports" && e.type !== "imports_type" && e.type !== "renders") continue;
+        let set = importTargets.get(e.source);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          importTargets.set(e.source, set);
+        }
+        set.add(e.target);
+      }
+    }
+    const crossRefs = [];
+    const seen = /* @__PURE__ */ new Set();
+    let resolvedSelf = 0;
+    let resolvedImport = 0;
+    let ambiguous = 0;
+    let dropped = 0;
+    for (const [, output] of layerOutputs) {
+      for (const node of output.nodes) {
+        const calls = node.effects?.calls;
+        if (!calls || calls.length === 0) continue;
+        const selfSyms = /* @__PURE__ */ new Set([
+          ...node.exports ?? [],
+          ...node.defines ?? []
+        ]);
+        const importedSyms = new Set(node.imported_names ?? []);
+        const myImports = importTargets.get(node.id);
+        const localSeen = /* @__PURE__ */ new Set();
+        for (const callee of calls) {
+          if (!BARE_IDENT.test(callee)) continue;
+          if (localSeen.has(callee)) continue;
+          localSeen.add(callee);
+          const key = `${node.id}\u2192${callee}`;
+          if (selfSyms.has(callee)) {
+            if (seen.has(key)) continue;
+            seen.add(key);
+            crossRefs.push({
+              source: node.id,
+              target: callee,
+              type: "calls",
+              layer: nodeLayer.get(node.id) ?? "ui",
+              defined_in: node.id
+            });
+            resolvedSelf++;
+            continue;
+          }
+          if (!importedSyms.has(callee)) {
+            dropped++;
+            continue;
+          }
+          const defs = (definers.get(callee) ?? []).filter((d) => d.nodeId !== node.id);
+          if (defs.length === 0) {
+            dropped++;
+            continue;
+          }
+          const fromImported = myImports ? defs.filter((d) => myImports.has(d.nodeId)) : [];
+          const chosen = fromImported.length > 0 ? fromImported : defs;
+          const owner = chosen[0];
+          const isAmbiguous = chosen.length > 1;
+          if (isAmbiguous) ambiguous++;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          const ref = {
+            source: node.id,
+            target: callee,
+            type: "calls",
+            layer: owner.layer,
+            defined_in: owner.nodeId
+          };
+          if (isAmbiguous) ref.ambiguous = true;
+          crossRefs.push(ref);
+          resolvedImport++;
+        }
+      }
+    }
+    crossRefs.sort(
+      (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target)
+    );
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: [],
+      warnings: [],
+      patterns: {
+        call_resolution: {
+          resolved_self: resolvedSelf,
+          resolved_import: resolvedImport,
+          ambiguous,
+          dropped,
+          symbols_defined: definers.size
+        }
+      }
+    };
+  }
+};
+
 // src/server/graph/core/parser-registry.ts
 function isMultiLayerParser(p) {
   return "layers" in p && Array.isArray(p.layers);
@@ -32885,7 +33153,8 @@ function registerBuiltins2(registry, disabled) {
     apiAnnotationsParser,
     urlLiteralScannerParser,
     staticRefScannerParser,
-    middlewareGatesParser
+    middlewareGatesParser,
+    callResolverParser
   ];
   for (const parser of builtins) {
     if (disabled.has(parser.id)) continue;
@@ -35889,6 +36158,10 @@ function handleWhoUses(args) {
       };
       const via = cr.via;
       if (Array.isArray(via)) entry.via = via;
+      const definedIn = cr.defined_in;
+      if (typeof definedIn === "string") entry.defined_in = definedIn;
+      const ambiguous = cr.ambiguous;
+      if (ambiguous) entry.ambiguous = true;
       hits.push(entry);
     }
   }
@@ -36556,7 +36829,7 @@ var McpSession = class {
       jsonrpc: "2.0",
       id: this.callId++,
       method: "initialize",
-      params: { protocolVersion: "2025-03-26", capabilities: {}, clientInfo: { name: "launchpod", version: "0.0.1" } }
+      params: { protocolVersion: "2025-03-26", capabilities: {}, clientInfo: { name: "launch-sequencer", version: "0.0.1" } }
     });
     const initResp = await httpRequest2(this.mcpUrl, {
       method: "POST",
@@ -36710,7 +36983,7 @@ async function validateRepoUrl(serverUrl, token) {
     console.error("Error: Repository URL mismatch");
     console.error(`  Project expects: ${remoteRepoUrl}`);
     console.error(`  Local origin:    ${localOrigin}`);
-    console.error("Run launchpod from the correct repository.");
+    console.error("Run launch-sequencer from the correct repository.");
     process.exit(1);
   }
 }
@@ -36999,6 +37272,14 @@ if (parsedArgs.subcommand === "graph:generate" || parsedArgs.subcommand === "gra
   );
   process.exit(result.status ?? 1);
 }
+if (parsedArgs.subcommand === "radar:teardown") {
+  const result = (0, import_child_process4.spawnSync)(
+    process.execPath,
+    [import_path9.default.join(__dirname, "radar-teardown-entry.js"), ...process.argv.slice(3)],
+    { stdio: "inherit" }
+  );
+  process.exit(result.status ?? 1);
+}
 if (parsedArgs.subcommand === "mcp:graph") {
   startGraphMcpServer();
 }
@@ -37458,18 +37739,23 @@ if (!__isMcpMode) {
       console.log(`LaunchPod radar \xB7 ${localUrl}`);
       console.log(`  cloud:   ${cfg.serverUrl}  \xB7  source: ${cfg.source}`);
       console.log(`  org:     ${cfg.orgSlug}  \xB7  project: ${cfg.projectSlug}`);
-      radar = new Radar({
-        projectRoot: PROJECT_DIR,
-        localPort: PORT,
-        localUrl,
-        serverUrl: cfg.serverUrl,
-        pat: cfg.pat,
-        orgSlug: cfg.orgSlug,
-        projectSlug: cfg.projectSlug
-      });
+      try {
+        radar = new Radar({
+          projectRoot: PROJECT_DIR,
+          localPort: PORT,
+          localUrl,
+          serverUrl: cfg.serverUrl,
+          pat: cfg.pat,
+          orgSlug: cfg.orgSlug,
+          projectSlug: cfg.projectSlug
+        });
+      } catch (err2) {
+        console.error(`${err2 instanceof Error ? err2.message : String(err2)}`);
+        process.exit(1);
+      }
       radar.attachWebSocketServer(server, "/api/radar/stream");
       radar.start();
-      initLaunchPodTerminalBridge(server, PROJECT_DIR);
+      initSequencerTerminalBridge(server, PROJECT_DIR);
       return;
     }
     if (token) {
@@ -37518,11 +37804,11 @@ if (!__isMcpMode) {
         activeCapabilities = await fetchCapabilities(existingCreds.serverUrl, existingCreds.token);
       }
       if (activeCapabilities.terminal) {
-        initLaunchPodTerminalBridge(server, PROJECT_DIR);
+        initSequencerTerminalBridge(server, PROJECT_DIR);
       }
       startPipelineSystem(existingCreds, activeCapabilities);
     } else if (activeCapabilities.terminal) {
-      initLaunchPodTerminalBridge(server, PROJECT_DIR);
+      initSequencerTerminalBridge(server, PROJECT_DIR);
     }
   }
   main().catch((err2) => {

package/dist/server/course-entry.js

@@ -214,7 +214,7 @@ Usage:
   launch-course rm  <name>
 
 The cred file (.launch-secure.cred.config) holds every course under \`profiles\`,
-with \`active\` selecting which one drives MCP / launch-pod auth. Legacy flat
+with \`active\` selecting which one drives MCP / launch-sequencer auth. Legacy flat
 files are auto-migrated on the first multi-profile op. \`launch-course set\`
 also rewrites .mcp.json's launch-secure.url so Claude Code routes to the right
 server on next MCP reconnect.