@closedrouter/cli 1.1.9 → 1.1.11

package/dist/index.js

@@ -5204,7 +5204,7 @@ var {
 } = exports_commander;
 
 // src/index.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 
 // ../node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs
 import { stripVTControlCharacters as S2 } from "node:util";
@@ -8658,10 +8658,10 @@ to scan and import local subscriptions!`, "Pool Empty");
 var import_picocolors12 = __toESM(require_picocolors(), 1);
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { spawn as spawn5 } from "node:child_process";
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname3, join as join14 } from "node:path";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname5, join as join16 } from "node:path";
 
 // src/model-picker.ts
 import { emitKeypressEvents as emitKeypressEvents2 } from "node:readline";
@@ -9418,15 +9418,121 @@ async function settingsCommand(options = {}) {
 import { randomUUID } from "node:crypto";
 import { createServer as createServer2, request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+
+// src/commands/launch-catalog.ts
+import { createHash as createHash2 } from "node:crypto";
+var modelLabel = (id) => `ClosedRouter: ${id}`;
+function transportModelId(id, family) {
+  const hash = createHash2("sha256").update(id).digest("hex").slice(0, 20);
+  return `${family === "claude" ? "claude-sonnet-4-6" : "gemini"}-closedrouter-${hash}`;
+}
+function createLaunchCatalog(models, selected) {
+  const ids = [...new Set([selected, ...models])];
+  return {
+    defaultModel: selected,
+    models: ids,
+    aliases: Object.fromEntries(ids.flatMap((id) => [
+      [transportModelId(id, "claude"), id],
+      [transportModelId(id, "gemini"), id]
+    ])),
+    fallbacks: ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "gemini-3.8-flash", "gemini-3.8-flash-medium", "gemini-3.8-flash-high", "gemini-2.5-flash", "gemini-2.5-flash-lite"]
+  };
+}
+function resolveLaunchModel(catalog, requested) {
+  let id = requested.replace(/^models\//, "").replace(/\[1m\]$/, "");
+  const fireworks = /^accounts\/fireworks\/models\/(.+)#anysphere\/[\w-]+$/.exec(id);
+  if (fireworks)
+    id = fireworks[1];
+  if (catalog.models.includes(id))
+    return id;
+  if (id.startsWith("closedrouter/") && catalog.models.includes(id.slice(13)))
+    return id.slice(13);
+  if (Object.hasOwn(catalog.aliases, id))
+    return catalog.aliases[id];
+  if (catalog.fallbacks.includes(id))
+    return catalog.defaultModel;
+  return;
+}
+function claudeModelPicker(models) {
+  return { replaceBuiltInOptions: true, options: models.map((id) => ({ model: id, label: modelLabel(id), description: "Via your ClosedRouter pool", behavesAs: "claude-sonnet-4-6" })) };
+}
+function codexModelCatalog(models) {
+  return { models: models.map((id, priority) => ({
+    slug: id,
+    display_name: modelLabel(id),
+    description: "Via your ClosedRouter pool",
+    priority,
+    visibility: "list",
+    supported_in_api: true,
+    supported_reasoning_levels: [],
+    experimental_supported_tools: [],
+    base_instructions: "You are a coding assistant working with the user in their workspace. Follow the user's task and applicable project instructions. Inspect relevant files before editing, preserve unrelated work, and verify changes with appropriate checks. Use the available tools when needed. Report the outcome and any material limitations clearly. The runtime supplies the configured inference model identity through ClosedRouter.",
+    default_reasoning_level: null,
+    supports_reasoning_summaries: false,
+    default_reasoning_summary: "none",
+    shell_type: "shell_command",
+    apply_patch_tool_type: "freeform",
+    web_search_tool_type: "text",
+    input_modalities: ["text"],
+    supports_parallel_tool_calls: false,
+    support_verbosity: false,
+    prefer_websockets: false,
+    supports_image_detail_original: false,
+    context_window: 8192,
+    auto_compact_token_limit: 7000,
+    truncation_policy: { mode: "tokens", limit: 6000 }
+  })) };
+}
+function geminiModelCatalog(models, selected) {
+  return {
+    experimental: { dynamicModelConfiguration: true },
+    modelConfigs: {
+      modelDefinitions: Object.fromEntries(models.map((id) => [id, {
+        displayName: modelLabel(id),
+        dialogDescription: "Via your ClosedRouter pool",
+        tier: "custom",
+        family: "closedrouter",
+        isVisible: true,
+        features: { thinking: false }
+      }])),
+      customAliases: Object.fromEntries(models.map((id) => [modelLabel(id), { modelConfig: { model: id } }])),
+      modelIdResolutions: Object.fromEntries(["auto", "pro", "flash", "flash-lite"].map((id) => [id, { default: selected }]))
+    }
+  };
+}
+function addModelIdentity(payload, model, protocol) {
+  const text = `ClosedRouter runtime model identity: this request is routed to the configured model ID ${JSON.stringify(model)} through ClosedRouter. The application's name and any vendor-shaped transport alias describe the client, not the underlying inference model. If asked which model you are using, report the configured model ID ${JSON.stringify(model)} and ClosedRouter as the provider. This runtime information supersedes conflicting model identity statements in the application's prompt; it does not change other task instructions.`;
+  if (protocol === "anthropic") {
+    const system = payload.system;
+    payload.system = typeof system === "string" ? `${system}
+
+${text}` : [...Array.isArray(system) ? system : [], { type: "text", text }];
+  } else if (protocol === "responses") {
+    payload.instructions = `${typeof payload.instructions === "string" ? payload.instructions + `
+
+` : ""}${text}`;
+  } else if (protocol === "chat") {
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    const firstUser = messages.findIndex((item) => item && typeof item === "object" && !["system", "developer"].includes(item.role));
+    const index = firstUser < 0 ? messages.length : firstUser;
+    payload.messages = [...messages.slice(0, index), { role: "system", content: text }, ...messages.slice(index)];
+  } else {
+    const system = payload.systemInstruction;
+    const instruction = system && typeof system === "object" && !Array.isArray(system) ? system : {};
+    payload.systemInstruction = { ...instruction, parts: [...Array.isArray(instruction.parts) ? instruction.parts : [], { text }] };
+  }
+}
+
+// src/bridge/launch-proxy.ts
 var HOP_HEADERS = new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade", "host"]);
-async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey) {
+async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey, modelOverride) {
   const upstream = new URL(gatewayUrl.replace(/\/+$/, "") + "/");
   if (!["http:", "https:"].includes(upstream.protocol) || upstream.username || upstream.password) {
     throw new Error("ClosedRouter server URL must use HTTP or HTTPS without embedded credentials.");
   }
   const launchId = randomUUID();
   const transport = upstream.protocol === "https:" ? httpsRequest : httpRequest;
-  const server = createServer2((incoming, outgoing) => {
+  const server = createServer2(async (incoming, outgoing) => {
     const authorized = incoming.headers.authorization === `Bearer ${localKey}` || incoming.headers["x-api-key"] === localKey || incoming.headers["x-goog-api-key"] === localKey;
     if (!authorized) {
       outgoing.writeHead(401).end();
@@ -9440,6 +9546,49 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey)
     const local = new URL(incoming.url, "http://localhost");
     target.pathname = upstream.pathname.replace(/\/$/, "") + local.pathname;
     target.search = local.search;
+    const catalog = typeof modelOverride === "object" ? modelOverride : undefined;
+    if (catalog && incoming.method === "GET" && ["/v1/models", "/v1beta/models"].includes(local.pathname)) {
+      const data = catalog.models.map((id) => ({ id, name: modelLabel(id), display_name: modelLabel(id), object: "model", type: "model", created: 0, created_at: "2026-01-01T00:00:00Z", owned_by: "closedrouter" }));
+      outgoing.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(local.pathname === "/v1/models" ? { object: "list", data, has_more: false, first_id: data[0]?.id, last_id: data.at(-1)?.id } : { models: catalog.models.map((id) => ({ name: `models/${id}`, displayName: modelLabel(id), supportedGenerationMethods: ["generateContent", "streamGenerateContent"] })) }));
+      return;
+    }
+    let rewrittenBody;
+    const gemini = /^\/v1beta\/models\/(.+):(generateContent|streamGenerateContent)$/.exec(local.pathname);
+    if (modelOverride && incoming.method === "POST" && (gemini || /^\/v1\/(?:messages(?:\/count_tokens)?|chat\/completions|responses)$/.test(local.pathname))) {
+      try {
+        const chunks = [];
+        let length = 0;
+        for await (const chunk of incoming) {
+          length += chunk.length;
+          if (length > 32 * 1024 * 1024) {
+            outgoing.writeHead(413).end();
+            return;
+          }
+          chunks.push(Buffer.from(chunk));
+        }
+        const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+          outgoing.writeHead(400).end();
+          return;
+        }
+        const payload = body;
+        const requested = gemini ? decodeURIComponent(gemini[1]) : typeof payload.model === "string" ? payload.model : catalog?.defaultModel || "";
+        const model = catalog ? resolveLaunchModel(catalog, requested) : modelOverride;
+        if (!model) {
+          outgoing.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: { type: "invalid_request_error", message: "This model is not in this launch's ClosedRouter catalog. Choose a supported model from the picker." } }));
+          return;
+        }
+        const tinyProbe = local.pathname === "/v1/messages" && !model.startsWith("claude-") && payload.model !== model && typeof payload.max_tokens === "number" && payload.max_tokens <= 16 && Array.isArray(payload.messages) && payload.messages.length === 1 && (!Array.isArray(payload.tools) || payload.tools.length === 0);
+        if (catalog)
+          addModelIdentity(payload, model, gemini ? "gemini" : local.pathname.startsWith("/v1/messages") ? "anthropic" : local.pathname === "/v1/responses" ? "responses" : "chat");
+        if (gemini)
+          target.pathname = upstream.pathname.replace(/\/$/, "") + `/v1beta/models/${encodeURIComponent(model)}:${gemini[2]}`;
+        rewrittenBody = JSON.stringify({ ...payload, ...!gemini ? { model } : {}, ...tinyProbe ? { max_tokens: 512 } : {} });
+      } catch {
+        outgoing.writeHead(400).end();
+        return;
+      }
+    }
     const headers = { ...incoming.headers };
     const connectionHeaders = String(headers.connection || "").split(",").map((x) => x.trim().toLowerCase());
     for (const key of Object.keys(headers)) {
@@ -9453,6 +9602,8 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey)
       delete headers["x-goog-api-key"];
       headers.authorization = `Bearer ${apiKey}`;
     }
+    if (rewrittenBody !== undefined)
+      delete headers["content-length"];
     const request = transport(target, { method: incoming.method, headers }, (response) => {
       const responseHeaders = { ...response.headers };
       for (const key of HOP_HEADERS)
@@ -9472,7 +9623,10 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey)
       if (!outgoing.writableFinished)
         request.destroy();
     });
-    incoming.pipe(request);
+    if (rewrittenBody !== undefined)
+      request.end(rewrittenBody);
+    else
+      incoming.pipe(request);
   });
   await new Promise((resolve, reject) => {
     server.once("error", reject);
@@ -9498,7 +9652,7 @@ async function startLaunchProxy(gatewayUrl, apiKey, harness, localKey = apiKey)
 import { createServer as createServer3 } from "node:http";
 import { request as httpRequest2 } from "node:http";
 import { request as httpsRequest2 } from "node:https";
-async function startAgyModelProxy(gatewayUrl, apiKey, model) {
+async function startAgyModelProxy(gatewayUrl, apiKey, model, catalog) {
   const upstream = new URL(gatewayUrl.replace(/\/+$/, "") + "/");
   if (!["https:", "http:"].includes(upstream.protocol)) {
     throw new Error("ClosedRouter server URL must use HTTP or HTTPS.");
@@ -9510,12 +9664,17 @@ async function startAgyModelProxy(gatewayUrl, apiKey, model) {
       return;
     }
     const requestUrl = new URL(incoming.url || "/", "http://localhost");
-    const match = /^\/v1beta\/models\/[^/:]+:(generateContent|streamGenerateContent)$/.exec(requestUrl.pathname);
+    const match = /^\/v1beta\/models\/([^/:]+):(generateContent|streamGenerateContent)$/.exec(requestUrl.pathname);
     if (incoming.method !== "POST" || !match) {
       outgoing.writeHead(404).end();
       return;
     }
-    const target = new URL(`v1beta/models/${encodeURIComponent(model)}:${match[1]}${requestUrl.search}`, upstream);
+    const selected = catalog ? resolveLaunchModel(catalog, decodeURIComponent(match[1])) : model;
+    if (!selected) {
+      outgoing.writeHead(400).end(JSON.stringify({ error: { message: "Choose a supported ClosedRouter model." } }));
+      return;
+    }
+    const target = new URL(`v1beta/models/${encodeURIComponent(selected)}:${match[2]}${requestUrl.search}`, upstream);
     const headers = { ...incoming.headers, host: target.host, "x-goog-api-key": apiKey };
     const upstreamRequest = requestUpstream(target, { method: "POST", headers }, (response) => {
       outgoing.writeHead(response.statusCode || 502, response.headers);
@@ -9555,28 +9714,26 @@ import { join as join9 } from "node:path";
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function registerAgyLaunchModel(homeDir, model, transportModel) {
+function registerAgyLaunchCatalog(homeDir, catalog, legacyTransport) {
   const path = join9(homeDir, ".gemini", "antigravity-cli", "settings.json");
   const settings = JSON.parse(readFileSync8(path, "utf8"));
-  if (!record(settings) || settings.modelProvider !== "gemini") {
+  if (!record(settings) || settings.modelProvider !== "gemini")
     throw new Error(`Set "modelProvider": "gemini" in ${path} before starting Antigravity through ClosedRouter.`);
-  }
   const config = settings.customModelsConfig ?? {};
   if (!record(config))
     throw new Error(`customModelsConfig must be an object in ${path}.`);
-  const models = config.customModels ?? {};
-  if (!record(models))
+  const previous = config.customModels ?? {};
+  if (!record(previous))
     throw new Error(`customModelsConfig.customModels must be an object in ${path}.`);
-  const label = `ClosedRouter: ${model}`;
-  const entry = { modelName: transportModel, apiProvider: "gemini" };
-  const existing = models[label];
-  if (existing !== undefined) {
-    if (!record(existing) || existing.modelName !== transportModel || existing.apiProvider !== "gemini" || Object.keys(existing).some((key) => !["modelName", "apiProvider"].includes(key))) {
+  const models = { ...previous };
+  for (const id of catalog.models) {
+    const label = modelLabel(id), name = transportModelId(id, "gemini"), existing = previous[label];
+    if (existing !== undefined && (!record(existing) || existing.apiProvider !== "gemini" || ![name, legacyTransport].includes(String(existing.modelName)) || Object.keys(existing).some((key) => !["modelName", "apiProvider"].includes(key)))) {
       throw new Error(`The custom model '${label}' already has different settings in ${path}. Rename that entry before launching it with ClosedRouter.`);
     }
-    return label;
+    models[label] = { modelName: name, apiProvider: "gemini" };
   }
-  settings.customModelsConfig = { ...config, customModels: { ...models, [label]: entry } };
+  settings.customModelsConfig = { ...config, customModels: models };
   const temporary = `${path}.closedrouter-${randomUUID2()}.tmp`;
   try {
     writeFileSync2(temporary, `${JSON.stringify(settings, null, 2)}
@@ -9586,7 +9743,7 @@ function registerAgyLaunchModel(homeDir, model, transportModel) {
     if (existsSync9(temporary))
       unlinkSync(temporary);
   }
-  return label;
+  return modelLabel(catalog.defaultModel);
 }
 
 // src/commands/cursor-launch.ts
@@ -9653,14 +9810,14 @@ function resolveCursorLocalExecutable(executablePath, homeDir = homedir9()) {
 // src/commands/desktop-launch.ts
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { accessSync, constants, existsSync as existsSync11, mkdirSync as mkdirSync2, mkdtempSync, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "node:fs";
+import { accessSync, closeSync, constants, existsSync as existsSync11, mkdirSync as mkdirSync2, mkdtempSync, openSync, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { dirname, isAbsolute, join as join11, relative, resolve } from "node:path";
 
 // src/commands/desktop-inspector.ts
 import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
 import { setTimeout as delay } from "node:timers/promises";
-async function installDesktopInspectorHook(hookPath, logPath, signal) {
+async function installDesktopInspectorHook(hookPath, logPath, signal, options = {}) {
   const deadline = Date.now() + 15000;
   let target;
   while (Date.now() < deadline && !signal.aborted) {
@@ -9671,7 +9828,7 @@ async function installDesktopInspectorHook(hookPath, logPath, signal) {
     await delay(100, undefined, { signal });
   }
   if (!target)
-    throw new Error("Antigravity did not expose its launch inspector. Close the paused app and retry with --open-only.");
+    throw new Error("Desktop app did not expose its launch inspector. Close the paused app and retry with --open-only.");
   const Socket = "Bun" in globalThis ? globalThis.WebSocket : wrapper_default;
   const socket = new Socket(target);
   let sequence = 0;
@@ -9685,7 +9842,7 @@ async function installDesktopInspectorHook(hookPath, logPath, signal) {
   signal.addEventListener("abort", abort, { once: true });
   const closed = () => {
     for (const item of pending.values())
-      item.reject(new Error("Antigravity launch inspector disconnected before the hook was installed."));
+      item.reject(new Error("Desktop app launch inspector disconnected before the hook was installed."));
     pending.clear();
   };
   socket.addEventListener("close", closed);
@@ -9712,21 +9869,29 @@ async function installDesktopInspectorHook(hookPath, logPath, signal) {
   try {
     await new Promise((resolve, reject) => {
       socket.addEventListener("open", () => resolve(), { once: true });
-      socket.addEventListener("error", () => reject(new Error("Could not connect to Antigravity's launch inspector.")), { once: true });
-      socket.addEventListener("close", () => reject(new Error("Antigravity's launch inspector closed.")), { once: true });
+      socket.addEventListener("error", () => reject(new Error("Could not connect to Desktop app's launch inspector.")), { once: true });
+      socket.addEventListener("close", () => reject(new Error("Desktop app's launch inspector closed.")), { once: true });
     });
     await rpc("Debugger.enable");
+    if (options.startupBreakpoint)
+      await rpc("Debugger.setBreakpointByUrl", options.startupBreakpoint);
     await rpc("Runtime.runIfWaitingForDebugger");
     await Promise.race([paused, delay(Math.max(1, deadline - Date.now()), undefined, { signal }).then(() => {
-      throw new Error("Antigravity did not pause before loading its application.");
+      throw new Error("Desktop app did not pause before loading its application.");
     })]);
     const result = await rpc("Runtime.evaluate", {
       expression: `process.getBuiltinModule('module').createRequire(process.cwd() + '/closedrouter-hook.cjs')(${JSON.stringify(hookPath)}); 'closedrouter-hook-loaded'`,
       returnByValue: true
     });
     if (result.exceptionDetails || result.result?.value !== "closedrouter-hook-loaded")
-      throw new Error("Could not install Antigravity's request hook. Close the paused app and use --open-only.");
+      throw new Error("Could not install Desktop app's request hook. Close the paused app and use --open-only.");
     await rpc("Debugger.resume");
+    if (options.readyPath) {
+      while (!existsSync10(options.readyPath) && Date.now() < deadline)
+        await delay(25, undefined, { signal });
+      if (!existsSync10(options.readyPath))
+        throw new Error("The desktop app did not enable its local provider runtime.");
+    }
     await rpc("Runtime.evaluate", { expression: "setTimeout(() => process.getBuiltinModule('inspector').close(), 100).unref(); true", returnByValue: true });
   } finally {
     clearTimeout(timer);
@@ -9776,7 +9941,7 @@ function createDesktopProfile(tool) {
   mkdirSync2(root, { recursive: true, mode: 448 });
   return mkdtempSync(join11(root, "session-"));
 }
-function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey, model, toolArgs = [], platform = process.platform) {
+function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey, model, toolArgs = [], platform = process.platform, models = model ? [model] : []) {
   validateDesktopArgs(toolArgs);
   const env = { ...process.env };
   delete env.ELECTRON_RUN_AS_NODE;
@@ -9796,6 +9961,8 @@ function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey,
       `model = ${JSON.stringify(model)}`,
       'model_provider = "closedrouter"',
       "",
+      `model_catalog_json = ${JSON.stringify(join11(codexHome, "closedrouter-models.json"))}`,
+      "",
       "[model_providers.closedrouter]",
       'name = "ClosedRouter"',
       `base_url = ${JSON.stringify(`${baseUrl.replace(/\/+$/, "")}/v1`)}`,
@@ -9805,6 +9972,7 @@ function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey,
     ].join(`
 `) });
     files.push({ path: join11(codexHome, "auth.json"), contents: JSON.stringify({ auth_mode: "apikey", OPENAI_API_KEY: localKey }) });
+    files.push({ path: join11(codexHome, "closedrouter-models.json"), contents: JSON.stringify(codexModelCatalog([...new Set([model, ...models])])) });
   }
   if (tool === "claude" && baseUrl && localKey && model) {
     userData = join11(profileDir, "user-data-3p");
@@ -9819,7 +9987,7 @@ function buildDesktopLaunchPlan(tool, executable, profileDir, baseUrl, localKey,
       inferenceGatewayApiKey: localKey,
       inferenceGatewayAuthScheme: "bearer",
       disableDeploymentModeChooser: true,
-      inferenceModels: [{ name: model }]
+      inferenceModels: [...new Set([model, ...models])].map((id) => ({ name: transportModelId(id, "claude"), labelOverride: modelLabel(id) }))
     }) });
   }
   Object.assign(env, appEnv);
@@ -9859,7 +10027,10 @@ function assertClaudeDesktopGatewaySupport(executable) {
 async function runDesktopLaunch(plan) {
   return await new Promise((resolveExit, reject) => {
     const controller = new AbortController;
-    const child = spawn3(plan.command, plan.args, { env: plan.env, stdio: "inherit" });
+    const stderrFile = plan.inspectorHook && plan.command !== "/usr/bin/open" ? openSync(plan.inspectorHook.logPath, "a", 384) : undefined;
+    const child = spawn3(plan.command, plan.args, { env: plan.env, stdio: stderrFile === undefined ? "inherit" : ["inherit", "inherit", stderrFile] });
+    if (stderrFile !== undefined)
+      closeSync(stderrFile);
     const interrupt = () => {
       controller.abort();
       child.kill("SIGTERM");
@@ -9880,7 +10051,7 @@ async function runDesktopLaunch(plan) {
       resolveExit(code ?? 1);
     });
     if (plan.inspectorHook) {
-      installDesktopInspectorHook(plan.inspectorHook.path, plan.inspectorHook.logPath, controller.signal).catch((error) => {
+      installDesktopInspectorHook(plan.inspectorHook.path, plan.inspectorHook.logPath, controller.signal, plan.inspectorHook).catch((error) => {
         child.kill("SIGTERM");
         cleanup();
         reject(error);
@@ -9895,9 +10066,6 @@ import { chmodSync, existsSync as existsSync12, mkdirSync as mkdirSync3 } from "
 import { homedir as homedir11 } from "node:os";
 import { dirname as dirname2, join as join12 } from "node:path";
 var CURSOR_APPLICATION_STORAGE = "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser";
-function cursorDesktopSupportsModel(model) {
-  return !model.startsWith("claude-") && !model.startsWith("gemini-");
-}
 async function writeSqlite(dbPath, sql) {
   let database;
   if ("Bun" in globalThis) {
@@ -9930,35 +10098,42 @@ function defaultCursorDatabase() {
   const root = process.platform === "darwin" ? join12(homedir11(), "Library", "Application Support") : process.platform === "win32" ? process.env.APPDATA || join12(homedir11(), "AppData", "Roaming") : join12(homedir11(), ".config");
   return join12(root, "Cursor", "User", "globalStorage", "state.vscdb");
 }
-async function configureCursorDesktop(profileDir, baseUrl, apiKey, model, sourceDb = defaultCursorDatabase()) {
-  if (!cursorDesktopSupportsModel(model))
-    throw new Error("Cursor desktop selects a separate provider for Claude/Gemini model names. Choose an OpenAI-compatible custom model or use cr start cursor with the local CLI runtime.");
+async function configureCursorDesktop(profileDir, baseUrl, apiKey, model, sourceDb = process.env.CLOSEDROUTER_CURSOR_AUTH_DB ?? defaultCursorDatabase(), models = [model]) {
+  const cursorModel = model;
+  const catalog = [...new Set([model, ...models])];
   const dbPath = join12(profileDir, "user-data", "User", "globalStorage", "state.vscdb");
   mkdirSync3(dirname2(dbPath), { recursive: true, mode: 448 });
   const items = new Map;
+  let membershipType;
   if (existsSync12(sourceDb)) {
     const auth = await querySqliteKeyValue(sourceDb, "cursorAuth/");
-    for (const name of ["accessToken", "refreshToken", "cachedEmail", "stripeMembershipAuthId", "membershipType", "cachedSignUpType"]) {
-      const key = `cursorAuth/${name}`;
-      const value = auth.get(key);
-      if (value !== undefined)
-        items.set(key, value);
+    if (auth.get("cursorAuth/accessToken") && auth.get("cursorAuth/refreshToken")) {
+      for (const name of ["accessToken", "refreshToken", "cachedEmail", "stripeMembershipAuthId", "stripeMembershipType", "stripeSubscriptionStatus", "membershipType", "cachedSignUpType"]) {
+        const key = `cursorAuth/${name}`;
+        const value = auth.get(key);
+        if (value !== undefined)
+          items.set(key, value);
+      }
+      membershipType = auth.get("cursorAuth/stripeMembershipType") || auth.get("cursorAuth/membershipType");
     }
   }
   items.set("cursorAuth/openAIKey", apiKey);
   items.set(CURSOR_APPLICATION_STORAGE, JSON.stringify({
     useOpenAIKey: true,
     openAIBaseUrl: `${baseUrl.replace(/\/+$/, "")}/v1`,
-    availableAPIKeyModels: [model],
+    availableAPIKeyModels: catalog,
     havePerformedSettingsServiceMigration: true,
+    localProviderModelIds: catalog,
+    localProviderAgentModelIds: catalog,
+    ...membershipType ? { membershipType } : {},
     aiSettings: {
-      userAddedModels: [model],
-      modelOverrideEnabled: [model],
+      userAddedModels: catalog,
+      modelOverrideEnabled: catalog,
       modelOverrideDisabled: [],
-      modelConfig: Object.fromEntries(["cmd-k", "composer", "background-composer", "plan-execution", "spec", "quick-agent"].map((feature) => [feature, { modelName: model, maxMode: false, selectedModels: [{ modelId: model, parameters: [] }] }]))
+      modelConfig: Object.fromEntries(["cmd-k", "composer", "background-composer", "plan-execution", "spec", "quick-agent"].map((feature) => [feature, { modelName: cursorModel, maxMode: false, selectedModels: [{ modelId: cursorModel, parameters: [] }] }]))
     }
   }));
-  items.set("lastSingleModelPreference", JSON.stringify({ composer: model, "cmd-k": model }));
+  items.set("lastSingleModelPreference", JSON.stringify({ composer: cursorModel, "cmd-k": cursorModel }));
   const quote = (value) => `'${value.replace(/'/g, "''")}'`;
   await writeSqlite(dbPath, [
     "BEGIN IMMEDIATE;",
@@ -9978,6 +10153,129 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { join as join13 } from "node:path";
+
+// src/commands/agy-desktop-catalog.ts
+function patchAntigravityCatalog(source, catalog) {
+  const provider = /this\.customModelsProvider=([\w$]+)\(this\.rootProvider,([\w$]+)=>\(\{customModels:\2\.appState\?\.customModelsConfig\?\.customModels\?\?\{\}\}\)\)/;
+  const context = /function ([\w$]+)\(\{children:([\w$]+),userStatus:([\w$]+),lastSelectedAgentModel:([\w$]+),setLastSelectedAgentModel:/;
+  const match = context.exec(source);
+  if (!provider.test(source) || !match)
+    throw new Error("This Antigravity build has an unsupported custom-model picker. Update the ClosedRouter launcher.");
+  const entries = catalog.models.map((id) => [`ClosedRouter: ${id}`, Object.keys(catalog.aliases).find((alias) => alias.startsWith("gemini-closedrouter-") && catalog.aliases[alias] === id)]);
+  const models = `Object.fromEntries(${JSON.stringify(entries)}.map(([label,id])=>[label,r(I.ModelInfoSchema,{modelId:I.Model.GOOGLE_GEMINI_INTERNAL_BYOM,apiProvider:I.APIProvider.API_PROVIDER_GOOGLE_EVERGREEN,chatModelName:label,modelName:id,maxTokens:32768,maxOutputTokens:4096,supportsContext:true,modelFeatures:r(I.ModelFeaturesSchema,{zeroShotCapable:true,supportsToolCalls:true,supportsImages:false,supportsThinking:false})})]))`;
+  const customState = /([\w$]+)=!!([\w$]+),([\w$]+)=\(0,([\w$]+)\.useMemo\)\(\(\)=>\(\{customModels:([\w$]+)\?\.customModels\?\?([\w$]+)\}\),\[\5\]\)/;
+  if (!customState.test(source))
+    throw new Error("This Antigravity build has an unsupported custom-model context.");
+  source = source.replace(customState, (_all, supported, _feature, state, react, input) => `${supported}=true,${state}=(0,${react}.useMemo)(()=>({customModels:${models}}),[${input}])`);
+  const customHeader = /showCustomModelHeader:[\w$]+,onAddCustomModel:/;
+  if (!customHeader.test(source))
+    throw new Error("This Antigravity build has an unsupported custom-model menu.");
+  source = source.replace(/showCustomModelHeader:[\w$]+,onAddCustomModel:[\w$]+,onEditCustomModel:[\w$]+/, "showCustomModelHeader:true,onAddCustomModel:undefined,onEditCustomModel:undefined");
+  source = source.replace(/([\w$]+)=([\w$]+)\.some\(([\w$]+)=>\3\.options\.length>0\);([\w$]+)=/, "$1=true;$4=");
+  source = source.replace(provider, (_all, selector, variable) => `this.customModelsProvider=${selector}(this.rootProvider,${variable}=>({customModels:${models}}))`);
+  const start = source.indexOf(match[0]);
+  const end = source.indexOf(`function `, start + match[0].length);
+  let body = source.slice(start, end);
+  const state = /\[([\w$]+),([\w$]+)\]=\(0,([\w$]+)\.useState\)\(null\)/;
+  if (!state.test(body) || !body.includes("clientModelConfigs||[]"))
+    throw new Error("This Antigravity build has an unsupported model-selection context.");
+  body = body.replace(state, (_all, value, setter, react) => `[${value},${setter}]=(0,${react}.useState)(${JSON.stringify(`ClosedRouter: ${catalog.defaultModel}`)})`).replace(/\([\w$]+\?\.cascadeModelConfigData\?\.clientModelConfigs\|\|\[\]\)/g, "([])").replace(/[\w$]+\?\.clientModelConfigs\|\|\[\]/g, "[]").replace(/[\w$]+\?\.clientModelSorts\|\|\[\]/g, "[]");
+  return source.slice(0, start) + body + source.slice(end);
+}
+function antigravityCatalogHook(catalog, marker) {
+  return `
+const {app} = require('electron');
+const patchCatalog = ${patchAntigravityCatalog.toString()};
+app.on('web-contents-created', (_event, contents) => {
+  const debuggerClient = contents.debugger;
+  try {
+    debuggerClient.attach('1.3');
+    debuggerClient.sendCommand('Fetch.enable', {patterns:[{urlPattern:'https://127.0.0.1:*/main.js',requestStage:'Response'}]}).catch(() => {});
+    debuggerClient.on('message', async (_event, method, params) => {
+      if (method !== 'Fetch.requestPaused') return;
+      try {
+        const url = new URL(params.request.url);
+        if (url.hostname !== '127.0.0.1' || url.pathname !== '/main.js' || params.responseStatusCode !== 200) {
+          await debuggerClient.sendCommand('Fetch.continueRequest', {requestId:params.requestId}); return;
+        }
+        const result = await debuggerClient.sendCommand('Fetch.getResponseBody', {requestId:params.requestId});
+        const source = result.base64Encoded ? Buffer.from(result.body,'base64').toString('utf8') : result.body;
+        const patched = patchCatalog(source, ${JSON.stringify(catalog)});
+        await debuggerClient.sendCommand('Fetch.fulfillRequest', {requestId:params.requestId,responseCode:200,
+          responseHeaders:(params.responseHeaders || []).filter(h=>!['content-length','content-encoding','transfer-encoding'].includes(h.name.toLowerCase())),
+          body:Buffer.from(patched).toString('base64')});
+        require('node:fs').writeFileSync(${JSON.stringify(marker)}, 'ready', {mode:0o600});
+        await debuggerClient.sendCommand('Fetch.disable');
+        debuggerClient.detach();
+      } catch (error) {
+        require('node:fs').writeFileSync(${JSON.stringify(marker + ".error")}, String(error.message), {mode:0o600});
+        await debuggerClient.sendCommand('Fetch.failRequest', {requestId:params.requestId,errorReason:'Failed'}).catch(()=>{});
+      }
+    });
+  } catch (error) {
+    require('node:fs').writeFileSync(${JSON.stringify(marker + ".error")}, String(error.message), {mode:0o600});
+  }
+});
+`;
+}
+
+// src/commands/model-branding.ts
+var CLOSEDROUTER_LOGO = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><rect width="24" height="24" rx="6" fill="#D4FE51"/><path d="M16.68 7.82A6.5 6.5 0 1 0 16.68 16.18" fill="none" stroke="#04080A" stroke-width="2.6" stroke-linecap="round"/><circle cx="18.2" cy="12" r="1.9" fill="#04080A"/></svg>';
+function installModelBranding(models, artwork) {
+  if (document.querySelector("[data-closedrouter-branding]"))
+    return;
+  const marker = document.createElement("meta");
+  marker.dataset.closedrouterBranding = "true";
+  document.head.append(marker);
+  const paint = () => {
+    for (const element of document.querySelectorAll('button,[role="button"],[role="option"],[role="menuitem"],[role="menuitemradio"],[data-testid="model-selector-item"]')) {
+      const text = element.innerText.trim().split(`
+`)[0];
+      if (!models.some((id) => text === id || text === `ClosedRouter: ${id}`))
+        continue;
+      const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+      while (walker.nextNode()) {
+        const node = walker.currentNode;
+        const value = node.textContent || "";
+        if (models.some((id) => value.trim() === `ClosedRouter: ${id}`))
+          node.textContent = value.replace("ClosedRouter: ", "");
+      }
+      if (element.querySelector(":scope > [data-closedrouter-logo]"))
+        continue;
+      const logo = document.createElement("img");
+      logo.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(artwork)}`;
+      logo.alt = "ClosedRouter";
+      logo.title = "Routed through ClosedRouter";
+      logo.dataset.closedrouterLogo = "true";
+      logo.style.cssText = "width:16px;height:16px;flex:0 0 16px;display:inline-block;vertical-align:middle;margin-inline-end:6px;pointer-events:none";
+      element.prepend(logo);
+    }
+  };
+  let scheduled = false;
+  const observer = new MutationObserver(() => {
+    if (scheduled)
+      return;
+    scheduled = true;
+    requestAnimationFrame(() => {
+      scheduled = false;
+      paint();
+    });
+  });
+  observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true });
+  paint();
+}
+function modelBrandingHook(models) {
+  const script = `(${installModelBranding.toString()})(${JSON.stringify(models)},${JSON.stringify(CLOSEDROUTER_LOGO)})`;
+  return `
+require('electron').app.on('web-contents-created', (_event, contents) => {
+  contents.on('did-finish-load', () => {
+    contents.executeJavaScript(${JSON.stringify(script)}).catch(() => {});
+  });
+});
+`;
+}
+
+// src/commands/agy-desktop.ts
 var MODS_CONTROL_URL = "http://127.0.0.1:59998";
 var MODS_PROXY_URL = "http://127.0.0.1:59997";
 async function assertAntigravityModsAvailable() {
@@ -10014,7 +10312,7 @@ function assertAntigravityDesktopHookSupport(executable) {
   if (index < 0 || binary[index + 32 + 5] !== 49)
     throw new Error("This Antigravity build disables launch inspector hooks. Use --open-only.");
 }
-async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_PROXY_URL) {
+async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_PROXY_URL, catalog) {
   const capability = randomUUID4();
   const controllers = new Set;
   const server = createServer4(async (incoming, outgoing) => {
@@ -10053,9 +10351,15 @@ async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_
           return;
         }
         const body = JSON.parse(raw.toString("utf8"));
+        const requested = body.modelName || body.model || model;
+        const selected = catalog ? resolveLaunchModel(catalog, requested) : model;
+        if (!selected) {
+          outgoing.writeHead(400).end(JSON.stringify({ error: { message: "Choose a supported ClosedRouter model." } }));
+          return;
+        }
         const request = body.request || body;
         payload = Buffer.from(JSON.stringify(request));
-        target = `${gatewayUrl}/v1beta/models/${encodeURIComponent(model)}:${generation[1]}${generation[1] === "streamGenerateContent" ? "?alt=sse" : ""}`;
+        target = `${gatewayUrl}/v1beta/models/${encodeURIComponent(selected)}:${generation[1]}${generation[1] === "streamGenerateContent" ? "?alt=sse" : ""}`;
         headers.authorization = `Bearer ${localKey}`;
         headers["content-type"] = "application/json";
       } else {
@@ -10136,8 +10440,9 @@ async function startAgyDesktopProxy(gatewayUrl, localKey, model, modsUrl = MODS_
     })
   };
 }
-function addAntigravityDesktopHook(plan, endpoint) {
+function addAntigravityDesktopHook(plan, endpoint, catalog) {
   const path = join13(plan.profileDir, "antigravity-hook.cjs");
+  const marker = join13(plan.profileDir, "model-catalog-ready");
   const contents = `const cp = require('node:child_process');
 const spawn = cp.spawn;
 cp.spawn = function(command, args, options) {
@@ -10159,10 +10464,10 @@ cp.spawn = function(command, args, options) {
   return spawn.call(this, command, args, options);
 };
 require('node:fs').writeFileSync(${JSON.stringify(join13(plan.profileDir, "hook-loaded"))}, 'ready', {mode: 0o600});
-`;
+` + (catalog ? antigravityCatalogHook(catalog, marker) + modelBrandingHook(catalog.models) : "");
   plan.files.push({ path, contents });
   const logPath = join13(plan.profileDir, "inspector.log");
-  plan.inspectorHook = { path, logPath };
+  plan.inspectorHook = { path, logPath, ...catalog ? { readyPath: marker } : {} };
   plan.args.push("--inspect-brk=127.0.0.1:0");
   if (plan.command === "/usr/bin/open") {
     const index = plan.args.indexOf("--args");
@@ -10170,6 +10475,242 @@ require('node:fs').writeFileSync(${JSON.stringify(join13(plan.profileDir, "hook-
   }
 }
 
+// src/commands/claude-desktop.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { copyFileSync, existsSync as existsSync14, linkSync, lstatSync, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readFileSync as readFileSync12, readdirSync as readdirSync2, readlinkSync, realpathSync, renameSync as renameSync2, rmSync, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname3, join as join14, relative as relative2 } from "node:path";
+function cloneClaudeElectronRuntime(source, destination) {
+  const clone = (from, to) => {
+    const info = lstatSync(from);
+    if (info.isSymbolicLink())
+      symlinkSync(readlinkSync(from), to);
+    else if (info.isDirectory()) {
+      mkdirSync4(to, { mode: 448 });
+      for (const name of readdirSync2(from))
+        clone(join14(from, name), join14(to, name));
+    } else if (info.isFile())
+      linkSync(from, to);
+    else
+      throw new Error("Unsupported file in the shared Electron runtime.");
+  };
+  clone(source, destination);
+  const contents = join14(destination, "Contents");
+  const roots = [contents, ...readdirSync2(join14(contents, "Frameworks")).filter((name) => name.endsWith(".app")).map((name) => join14(contents, "Frameworks", name, "Contents"))];
+  const owned = [];
+  for (const root of roots) {
+    if (!realpathSync(root).startsWith(realpathSync(destination) + "/"))
+      throw new Error("Electron helper signing must stay inside the owned runtime.");
+    for (const name of readdirSync2(join14(root, "MacOS"))) {
+      const target = join14(root, "MacOS", name);
+      if (!lstatSync(target).isFile())
+        throw new Error("Electron helper executables must be regular files.");
+      const original = join14(source, relative2(destination, target));
+      unlinkSync2(target);
+      copyFileSync(original, target);
+      owned.push(target);
+    }
+    rmSync(join14(root, "_CodeSignature"), { recursive: true, force: true });
+  }
+  return owned;
+}
+function prepareClaudeElectronRuntime(runtime, sourceApp) {
+  const source = dirname3(dirname3(dirname3(realpathSync(runtime))));
+  if (!source.endsWith(".app"))
+    throw new Error("Claude's shared runtime must be a macOS Electron app bundle.");
+  const framework = join14(source, "Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework");
+  const fingerprint = createHash3("sha256").update(JSON.stringify({
+    schema: 1,
+    source,
+    sourceApp,
+    executable: statSync2(runtime).mtimeMs,
+    framework: statSync2(framework).mtimeMs,
+    appInfo: readFileSync12(join14(sourceApp, "Contents/Info.plist"), "utf8")
+  })).digest("hex").slice(0, 24);
+  const root = join14(getConfigDir(), "desktop-runtime", "claude");
+  mkdirSync4(root, { recursive: true, mode: 448 });
+  const cache = join14(root, fingerprint), app = join14(cache, "Electron.app");
+  const executable = join14(app, "Contents/MacOS", runtime.split("/").at(-1));
+  const marker = join14(cache, "ready.json");
+  if (existsSync14(marker)) {
+    const saved = JSON.parse(readFileSync12(marker, "utf8"));
+    if (saved.fingerprint !== fingerprint || saved.source !== source)
+      throw new Error("Claude's owned runtime cache has unexpected metadata.");
+    execFileSync2("/usr/bin/codesign", ["--verify", app], { stdio: "pipe" });
+    return executable;
+  }
+  const staging = mkdtempSync2(join14(root, ".preparing-"));
+  try {
+    const target = join14(staging, "Electron.app");
+    const owned = cloneClaudeElectronRuntime(source, target);
+    const entitlements = join14(staging, "entitlements.plist");
+    writeFileSync4(entitlements, '<?xml version="1.0"?><plist version="1.0"><dict><key>com.apple.security.cs.allow-jit</key><true/><key>com.apple.security.cs.disable-library-validation</key><true/><key>com.apple.security.virtualization</key><true/></dict></plist>', { mode: 384 });
+    for (const path of [...owned.slice(1), owned[0]]) {
+      if (statSync2(path).nlink !== 1)
+        throw new Error("Refusing to sign a shared Electron executable.");
+      execFileSync2("/usr/bin/codesign", ["--force", "--sign", "-", "--entitlements", entitlements, path], { stdio: "pipe" });
+    }
+    execFileSync2("/usr/bin/codesign", ["--verify", target], { stdio: "pipe" });
+    writeFileSync4(join14(staging, "ready.json"), JSON.stringify({ fingerprint, source, sourceApp }), { mode: 384 });
+    renameSync2(staging, cache);
+    return executable;
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true });
+    throw new Error("Could not prepare Claude's lightweight runtime. The shared runtime and ClosedRouter config directory must be on the same filesystem, with codesign available.", { cause: error });
+  }
+}
+function findClaudeSharedElectron(sourceApp, home = homedir13()) {
+  const explicit = process.env.CLOSEDROUTER_CLAUDE_ELECTRON || process.env.CLAUDE_DESKTOP_AUTH_ELECTRON;
+  if (explicit && existsSync14(explicit))
+    return explicit;
+  const info = JSON.parse(execFileSync2("/usr/bin/plutil", ["-convert", "json", "-o", "-", join14(sourceApp, "Contents/Frameworks/Electron Framework.framework/Versions/A/Resources/Info.plist")], { encoding: "utf8" }));
+  const major = info.CFBundleVersion.split(".")[0];
+  const root = join14(home, ".antigravity_cockpit", "electron_runtime");
+  if (!existsSync14(root))
+    return;
+  const versions = readdirSync2(root).filter((version) => version.startsWith(`${major}.`)).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+  return versions.map((version) => join14(root, version, `darwin-${process.arch}`, "Electron.app/Contents/MacOS/Electron")).find((path) => existsSync14(path));
+}
+function useClaudeSharedElectron(plan, runtime, sourceApp, toolArgs = [], launchServices = false) {
+  const args = [join14(sourceApp, "Contents/Resources/app.asar"), `--user-data-dir=${join14(plan.profileDir, "user-data-3p")}`, ...toolArgs];
+  plan.command = launchServices ? "/usr/bin/open" : runtime;
+  plan.args = launchServices ? ["-W", "-n", "-a", dirname3(dirname3(dirname3(runtime))), "--args", ...args] : args;
+}
+function addClaudeDesktopHook(plan, baseUrl, localKey, sourceApp, models) {
+  const path = join14(plan.profileDir, "claude-hook.cjs");
+  plan.files.push({ path, contents: `${sourceApp ? `const electron = require('electron');
+Object.defineProperty(process, 'resourcesPath', {value: ${JSON.stringify(join14(sourceApp, "Contents/Resources"))}});
+Object.defineProperty(electron.app, 'isPackaged', {get: () => true});
+electron.app.setPath('userData', ${JSON.stringify(join14(plan.profileDir, "user-data-3p"))});
+process.env.CLAUDE_USER_DATA_DIR = ${JSON.stringify(join14(plan.profileDir, "user-data-3p"))};
+` : ""}const cp = require('node:child_process');
+const spawn = cp.spawn;
+cp.spawn = function(command, args, options) {
+  if (typeof command === 'string' && /(?:^|[\\\\/])claude(?:\\.exe)?$/.test(command)) {
+    options = { ...options, env: { ...process.env, ...options?.env,
+      ANTHROPIC_BASE_URL: ${JSON.stringify(baseUrl)}, ANTHROPIC_API_KEY: ${JSON.stringify(localKey)} } };
+    delete options.env.ANTHROPIC_AUTH_TOKEN;
+  }
+  return spawn.call(this, command, args, options);
+};
+const { autoUpdater } = require('electron');
+if (autoUpdater) {
+  autoUpdater.checkForUpdates = () => {};
+  autoUpdater.quitAndInstall = () => {};
+}
+require('node:fs').writeFileSync(${JSON.stringify(join14(plan.profileDir, "hook-loaded"))}, 'ready', {mode: 0o600});
+` + (models ? modelBrandingHook(models) : "") });
+  const logPath = join14(plan.profileDir, "inspector.log");
+  plan.inspectorHook = { path, logPath };
+  plan.args.push("--inspect-brk=127.0.0.1:0");
+  if (plan.command === "/usr/bin/open")
+    plan.args.splice(plan.args.indexOf("--args"), 0, "--stderr", logPath);
+}
+
+// src/commands/cursor-desktop-hook.ts
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { dirname as dirname4, join as join15 } from "node:path";
+var FLAGS = /([\w$]+)=\{extensionIsDev:[^{}]{1,1000}localMode:(?:!1|false)\}/;
+function addCursorDesktopLocalHook(plan, app, catalog) {
+  const resources = app.endsWith(".app") ? join15(app, "Contents/Resources/app") : join15(dirname4(app), "resources/app");
+  const source = join15(resources, "out/main.js");
+  const mainSource = readFileSync13(source, "utf8");
+  const mainMatch = FLAGS.exec(mainSource);
+  if (!mainMatch)
+    throw new Error("This Cursor Desktop build does not include the supported local agent runtime. Update Cursor or use cr start cursor with Cursor Agent Local.");
+  const nativeKey = mainMatch[1];
+  const redirects = {};
+  for (const variant of ["desktop", "glass"]) {
+    const renderer = join15(resources, `out/vs/workbench/workbench.${variant}.main.js`);
+    if (!existsSync15(renderer) && variant === "glass")
+      continue;
+    const rendererSource = readFileSync13(renderer, "utf8");
+    const rendererMatch = FLAGS.exec(rendererSource);
+    if (!rendererMatch || !rendererSource.includes("runLocalAgentInExtensionHost"))
+      throw new Error("This Cursor Desktop build does not include the supported local agent runtime. Update Cursor or use cr start cursor with Cursor Agent Local.");
+    const authMethod = /isAuthenticated\(\)\{const ([\w$]+)=this\.accessToken\(\),([\w$]+)=this\.refreshToken\(\);return this\.scheduleTeamPolicyCheck\(\),!!\(\1&&\2\)\}/;
+    if (!authMethod.test(rendererSource))
+      throw new Error("This Cursor Desktop build has an unsupported login controller. Update the ClosedRouter launcher before using local provider mode.");
+    let modifiedRenderer = rendererSource.replace(rendererMatch[0], rendererMatch[0].replace(/localMode:(?:!1|false)/, "localMode:!0")).replace(authMethod, `isAuthenticated(){const e=this.accessToken(),t=this.refreshToken();if(!e&&!t&&${rendererMatch[1]}.localMode&&this.byokProviderKeyStorage?.openAIKey()&&this._reactiveStorageService.applicationUserPersistentStorage.openAIBaseUrl)return true;return this.scheduleTeamPolicyCheck(),!!(e&&t)}`);
+    if (catalog) {
+      const nativeCatalog = "getAvailableDefaultModels(){return[...this._availableDefaultModels()]}";
+      if (!modifiedRenderer.includes(nativeCatalog))
+        throw new Error("This Cursor Desktop build has an unsupported model catalog controller. Update the ClosedRouter launcher.");
+      const entries = catalog.models.map((id) => ({
+        name: id,
+        serverModelName: id,
+        clientDisplayName: id,
+        inputboxShortModelName: id,
+        defaultOn: true,
+        supportsAgent: true,
+        supportsPlanMode: true,
+        supportsNonMaxMode: true,
+        supportsImages: false,
+        supportsThinking: false,
+        supportsCmdK: true,
+        supportsSmartModeClassifier: true,
+        parameterDefinitions: [],
+        variants: [],
+        legacySlugs: [],
+        idAliases: [],
+        namedModelSectionIndex: 0,
+        tooltipData: { markdownContent: "Via your ClosedRouter pool" }
+      }));
+      modifiedRenderer = modifiedRenderer.replace(nativeCatalog, `getAvailableDefaultModels(){return ${JSON.stringify(entries)}}`);
+      const display = /function ([\w$]+)\(([\w$]+),([\w$]+),([\w$]+)\)\{if\(\2\.includes\(","\)\)/;
+      if (!display.test(modifiedRenderer))
+        throw new Error("This Cursor Desktop build has an unsupported model-label formatter. Update the ClosedRouter launcher.");
+      modifiedRenderer = modifiedRenderer.replace(display, (all, _fn, model) => all.replace("{if(", `{if(${JSON.stringify(catalog.models)}.includes(${model}))return 'ClosedRouter: '+${model};if(`));
+    }
+    const patched = join15(plan.profileDir, `cursor-local-workbench${variant === "desktop" ? "" : "-glass"}.js`);
+    redirects[renderer] = patched;
+    plan.files.push({ path: patched, contents: modifiedRenderer });
+  }
+  const hook = join15(plan.profileDir, "cursor-local-hook.cjs");
+  const marker = join15(plan.profileDir, "main-local-mode-enabled");
+  plan.files.push({ path: hook, contents: `const {app, session} = require('electron');
+const fs = require('node:fs');
+const redirects = ${JSON.stringify(redirects)};
+function installProtocolHook() {
+  const protocol = session.defaultSession.protocol;
+  const prototype = Object.getPrototypeOf(protocol);
+  const register = prototype.registerFileProtocol;
+  prototype.registerFileProtocol = function(scheme, handler, ...rest) {
+    if (scheme !== 'vscode-file') return register.call(this, scheme, handler, ...rest);
+    return register.call(this, scheme, (request, callback) => handler(request, result => {
+      if (/workbench.(?:desktop|glass).main.js/.test(request.url)) fs.writeFileSync(${JSON.stringify(join15(plan.profileDir, "renderer-request.json"))}, JSON.stringify({type: typeof result, path: result?.path}), {mode: 0o600});
+      if (result && typeof result === 'object' && Object.hasOwn(redirects, result.path)) {
+        result = {...result, path: redirects[result.path]};
+        fs.writeFileSync(${JSON.stringify(join15(plan.profileDir, "renderer-local-mode-served"))}, 'ready', {mode: 0o600});
+      }
+      callback(result);
+    }), ...rest);
+  };
+  fs.writeFileSync(${JSON.stringify(join15(plan.profileDir, "protocol-hook-loaded"))}, 'ready', {mode: 0o600});
+}
+if (app.isReady()) installProtocolHook(); else app.once('ready', installProtocolHook);
+require('node:fs').writeFileSync(${JSON.stringify(join15(plan.profileDir, "hook-loaded"))}, 'ready', {mode: 0o600});
+` + (catalog ? modelBrandingHook(catalog.models) : "") });
+  const point = mainSource.slice(0, mainMatch.index + mainMatch[0].length).split(`
+`);
+  const logPath = join15(plan.profileDir, "inspector.log");
+  plan.inspectorHook = {
+    path: hook,
+    logPath,
+    startupBreakpoint: {
+      urlRegex: source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "$",
+      lineNumber: point.length - 1,
+      columnNumber: point.at(-1).length,
+      condition: `typeof ${nativeKey} === 'object' && (${nativeKey}.localMode = true, process.getBuiltinModule('fs').writeFileSync(${JSON.stringify(marker)}, 'ready', {mode: 0o600}), false)`
+    },
+    readyPath: marker
+  };
+  plan.args.push("--inspect-brk=127.0.0.1:0");
+  if (plan.command === "/usr/bin/open")
+    plan.args.splice(plan.args.indexOf("--args"), 0, "--stderr", logPath);
+}
+
 // src/commands/start.ts
 function isGatewayModelAvailable(availableModels, model) {
   return availableModels.includes(model);
@@ -10186,7 +10727,7 @@ var TOOL_OPTIONS = [
 var DESKTOP_TOOL_OPTIONS = [
   { value: "codex-desktop", label: "Codex Desktop", hint: "Responses API with an isolated app profile" },
   { value: "antigravity-desktop", label: "Antigravity Desktop", hint: "ClosedRouter routing through your antigravity-mods hook" },
-  { value: "cursor-desktop", label: "Cursor Desktop", hint: "Automatic API-key setup; requires a public gateway" },
+  { value: "cursor-desktop", label: "Cursor Desktop", hint: "Local model engine using your ClosedRouter pool" },
   { value: "claude-desktop", label: "Claude Desktop", hint: "Inference gateway with an isolated app profile" }
 ];
 function getStartToolOptions(desktopOnly = false) {
@@ -10216,7 +10757,7 @@ function assertNoManagedCodexArgs(args) {
     throw new Error(`Remove ${conflicting}; ClosedRouter manages the Codex profile and model. Put other arguments after --.`);
   }
 }
-function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir = homedir13(), executablePath, agyRouting) {
+function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir = homedir14(), executablePath, agyRouting, catalog) {
   const baseUrl = normalizeServerUrl(serverUrl);
   const env = { ...process.env };
   const command = executablePath || tool;
@@ -10236,18 +10777,20 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
     return {
       tool,
       command,
-      args: ["--model", model, ...toolArgs],
+      args: ["--model", model, ...catalog ? ["--settings", JSON.stringify({ modelPicker: claudeModelPicker(catalog.models) })] : [], ...toolArgs],
       env
     };
   }
   if (tool === "codex") {
     assertNoManagedCodexArgs(toolArgs);
-    const codexHome = process.env.CODEX_HOME || join14(homeDir, ".codex");
+    const codexHome = process.env.CODEX_HOME || join16(homeDir, ".codex");
     const profileName = "closedrouter-launch";
-    const configPath = join14(codexHome, `${profileName}.config.toml`);
+    const configPath = join16(codexHome, `${profileName}.config.toml`);
+    const catalogPath = join16(codexHome, "closedrouter-models.json");
     const configLines = [
       `model = ${tomlString(model)}`,
       `model_provider = ${tomlString(profileName)}`,
+      ...catalog ? [`model_catalog_json = ${tomlString(catalogPath)}`] : [],
       "",
       `[model_providers.${profileName}]`,
       `name = ${tomlString("ClosedRouter")}`,
@@ -10263,14 +10806,15 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
       args: ["--profile", profileName, ...toolArgs],
       env,
       configFile: { path: configPath, contents: configLines.join(`
-`) }
+`) },
+      ...catalog ? { extraFiles: [{ path: catalogPath, contents: JSON.stringify(codexModelCatalog(catalog.models)) }] } : {}
     };
   }
   if (tool === "gemini") {
     env.GEMINI_API_KEY = apiKey;
     env.GEMINI_MODEL = model;
     env.GOOGLE_GEMINI_BASE_URL = baseUrl;
-    const configPath = join14(homeDir, ".closedrouter", "gemini-launch.settings.json");
+    const configPath = join16(homeDir, ".closedrouter", "gemini-launch.settings.json");
     env.GEMINI_CLI_SYSTEM_SETTINGS_PATH = configPath;
     return {
       tool,
@@ -10279,7 +10823,7 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
       env,
       configFile: {
         path: configPath,
-        contents: `${JSON.stringify({ security: { auth: { selectedType: "gemini-api-key" } } }, null, 2)}
+        contents: `${JSON.stringify({ security: { auth: { selectedType: "gemini-api-key" } }, ...catalog ? geminiModelCatalog(catalog.models, model) : {} }, null, 2)}
 `
       }
     };
@@ -10305,8 +10849,9 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
     return {
       tool,
       command,
-      args: ["--model", `openai/${model}`, ...toolArgs],
-      env
+      args: ["--model", `openai/${catalog ? "closedrouter/" : ""}${model}`, ...catalog ? ["--model-metadata-file", join16(homeDir, ".closedrouter", "aider-models.json")] : [], ...toolArgs],
+      env,
+      ...catalog ? { configFile: { path: join16(homeDir, ".closedrouter", "aider-models.json"), contents: JSON.stringify(Object.fromEntries(catalog.models.map((id) => [`openai/closedrouter/${id}`, { litellm_provider: "openai", mode: "chat", max_input_tokens: 8192, max_output_tokens: 4096, supports_function_calling: true }]))) } } : {}
     };
   }
   const config = {
@@ -10319,7 +10864,7 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
           baseURL: `${baseUrl}/v1`,
           apiKey: "{env:CLOSEDROUTER_API_KEY}"
         },
-        models: { [model]: { name: model } }
+        models: Object.fromEntries((catalog?.models || [model]).map((id) => [id, { name: modelLabel(id) }]))
       }
     }
   };
@@ -10333,9 +10878,9 @@ function buildLaunchPlan(tool, serverUrl, apiKey, model, toolArgs = [], homeDir
   };
 }
 function writeOwnedConfig(file) {
-  mkdirSync4(dirname3(file.path), { recursive: true, mode: 448 });
+  mkdirSync5(dirname5(file.path), { recursive: true, mode: 448 });
   try {
-    const existing = readFileSync12(file.path, "utf8");
+    const existing = readFileSync14(file.path, "utf8");
     if (file.path.endsWith(".config.toml") && !existing.includes('name = "ClosedRouter"')) {
       throw new Error(`Refusing to replace an existing Codex profile at ${file.path}.`);
     }
@@ -10343,14 +10888,14 @@ function writeOwnedConfig(file) {
     if (error instanceof Error && error.message.startsWith("Refusing to replace"))
       throw error;
   }
-  writeFileSync4(file.path, file.contents, { encoding: "utf8", mode: 384 });
+  writeFileSync5(file.path, file.contents, { encoding: "utf8", mode: 384 });
 }
 function modelSupportsHarness(model, tool) {
   const parameters = model.supported_parameters;
   return (model.status === undefined || model.status === "available") && (model.available_tool_account_count === undefined || model.available_tool_account_count > 0) && (!Array.isArray(parameters) || parameters.includes("tools"));
 }
 function discoverAgyTransportModel(command, apiKey) {
-  const output = execFileSync2(command, ["models"], {
+  const output = execFileSync3(command, ["models"], {
     encoding: "utf8",
     timeout: 1e4,
     stdio: ["ignore", "pipe", "ignore"],
@@ -10363,7 +10908,7 @@ function discoverAgyTransportModel(command, apiKey) {
 }
 function assertAgyCustomModel(command, label, apiKey) {
   try {
-    const output = execFileSync2(command, ["models"], { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, GEMINI_API_KEY: apiKey, GOOGLE_GEMINI_BASE_URL: "http://127.0.0.1:1" } });
+    const output = execFileSync3(command, ["models"], { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, GEMINI_API_KEY: apiKey, GOOGLE_GEMINI_BASE_URL: "http://127.0.0.1:1" } });
     if (output.split(/\r?\n/).some((line) => line.split("\t")[0] === label))
       return;
   } catch {
@@ -10372,9 +10917,9 @@ function assertAgyCustomModel(command, label, apiKey) {
   throw new Error(`This version of agy did not recognize '${label}'. Update agy to use ClosedRouter's accurate model display.`);
 }
 function assertAgyGeminiMode(homeDir) {
-  const settingsPath = join14(homeDir, ".gemini", "antigravity-cli", "settings.json");
+  const settingsPath = join16(homeDir, ".gemini", "antigravity-cli", "settings.json");
   try {
-    const settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
+    const settings = JSON.parse(readFileSync14(settingsPath, "utf8"));
     if (settings?.modelProvider === "gemini")
       return;
   } catch {}
@@ -10416,13 +10961,17 @@ async function runTool(plan) {
 async function startCommand(options = {}) {
   const groupingOverride = options.groupBy === undefined ? undefined : parseModelGrouping(options.groupBy);
   const { tool, desktop } = await selectTool(options.tool, options.desktop);
+  if (options.desktopInspector && (!desktop || tool !== "claude"))
+    throw new Error("--desktop-inspector is supported for Claude Desktop only.");
   if (options.openOnly && !desktop)
     throw new Error("--open-only requires --desktop.");
   if (desktop && !isDesktopTool(tool))
     throw new Error(`Desktop launch is not supported for ${tool}. Choose codex, claude, cursor, or antigravity.`);
   if (desktop)
     validateDesktopArgs(options.toolArgs || []);
-  const executablePath = desktop && isDesktopTool(tool) ? resolveDesktopExecutable(tool, options.executablePath) : tool === "cursor" ? resolveCursorLocalExecutable(options.executablePath) : options.executablePath;
+  let executablePath = desktop && isDesktopTool(tool) ? resolveDesktopExecutable(tool, options.executablePath) : tool === "cursor" ? resolveCursorLocalExecutable(options.executablePath) : options.executablePath;
+  const sourceApp = executablePath;
+  let sharedClaudeElectron;
   if (desktop && isDesktopTool(tool) && options.openOnly) {
     if (options.model || options.key || options.server)
       throw new Error("Open-only desktop launches do not use --model, --key, or --server.");
@@ -10432,8 +10981,17 @@ async function startCommand(options = {}) {
     process.exitCode = await runDesktopLaunch(plan);
     return;
   }
-  if (desktop && tool === "claude")
+  if (desktop && tool === "claude") {
     assertClaudeDesktopGatewaySupport(executablePath);
+    if (process.platform === "darwin" && executablePath.endsWith(".app")) {
+      sharedClaudeElectron = findClaudeSharedElectron(executablePath);
+      if (sharedClaudeElectron) {
+        sharedClaudeElectron = prepareClaudeElectronRuntime(sharedClaudeElectron, executablePath);
+        M2.info("Using the lightweight Claude launcher with Cowork virtualization support. Existing framework files are shared.");
+      } else if (options.desktopInspector)
+        throw new Error("No compatible shared Electron runtime was found. Set CLOSEDROUTER_CLAUDE_ELECTRON to an installed Electron executable or omit --desktop-inspector to use Claude's native gateway mode.");
+    }
+  }
   if (desktop && tool === "agy") {
     assertAntigravityDesktopHookSupport(executablePath);
     await assertAntigravityModsAvailable();
@@ -10444,7 +11002,7 @@ async function startCommand(options = {}) {
   const apiKey = await ensurePlatformKey(tool, client, options);
   client.setApiKey(apiKey);
   const models = await client.listGatewayModels({ preferApiKey: true });
-  const eligibleModels = models.filter((item) => modelSupportsHarness(item, tool) && (!desktop || tool !== "cursor" || cursorDesktopSupportsModel(gatewayModelId(item))));
+  const eligibleModels = models.filter((item) => modelSupportsHarness(item, tool));
   const availableModels = [...new Set(eligibleModels.map(gatewayModelId).filter(Boolean))].sort();
   let model = options.model?.trim();
   if (!model) {
@@ -10469,24 +11027,36 @@ async function startCommand(options = {}) {
   if (!isGatewayModelAvailable(availableModels, model)) {
     throw new Error(`Model '${model}' is not available for ${tool} with this platform key. Agent clients require a provider that supports gateway function tools. Choose another model from ClosedRouter's model catalog.`);
   }
+  const catalog = createLaunchCatalog(availableModels, model);
   if (desktop && tool === "cursor") {
-    const plan = buildDesktopLaunchPlan("cursor", executablePath, createDesktopProfile("cursor"), undefined, undefined, undefined, options.toolArgs);
-    writeDesktopLaunchPlan(plan);
-    await configureCursorDesktop(plan.profileDir, serverUrl, apiKey, model);
-    M2.info(`Starting Cursor desktop with ${model}. API key, gateway URL, and model selection are configured. Profile: ${plan.profileDir}.`);
-    M2.warn("Cursor's standard editor sends BYOK requests through Cursor's servers, so the gateway URL must be publicly reachable. Cursor account and feature restrictions still apply.");
-    process.exitCode = await runDesktopLaunch(plan);
+    const localKey = randomUUID5();
+    const relay = await startLaunchProxy(serverUrl, apiKey, "cursor-desktop", localKey, catalog);
+    try {
+      const plan = buildDesktopLaunchPlan("cursor", executablePath, createDesktopProfile("cursor"), undefined, undefined, undefined, options.toolArgs);
+      addCursorDesktopLocalHook(plan, executablePath, catalog);
+      writeDesktopLaunchPlan(plan);
+      await configureCursorDesktop(plan.profileDir, relay.baseUrl, localKey, model, undefined, catalog.models);
+      M2.info(`Starting Cursor desktop local provider mode with ${model}. Model requests use ClosedRouter, without a paid Cursor subscription. Profile: ${plan.profileDir}. Keep cr running until you close this app instance.`);
+      process.exitCode = await runDesktopLaunch(plan);
+    } finally {
+      await relay.close();
+    }
     return;
   }
   if (desktop && (tool === "codex" || tool === "claude" || tool === "agy")) {
     const localKey = randomUUID5();
-    const relay = await startLaunchProxy(serverUrl, apiKey, `${tool}-desktop`, localKey);
+    const relay = await startLaunchProxy(serverUrl, apiKey, `${tool}-desktop`, localKey, catalog);
     let agyDesktopProxy;
     try {
-      const plan = buildDesktopLaunchPlan(tool, executablePath, createDesktopProfile(tool), relay.baseUrl, localKey, model, options.toolArgs);
+      const plan = buildDesktopLaunchPlan(tool, executablePath, createDesktopProfile(tool), relay.baseUrl, localKey, model, options.toolArgs, process.platform, catalog.models);
+      if (sharedClaudeElectron && tool === "claude") {
+        if (sharedClaudeElectron)
+          useClaudeSharedElectron(plan, sharedClaudeElectron, sourceApp, options.toolArgs, true);
+        addClaudeDesktopHook(plan, relay.baseUrl, localKey, sourceApp, catalog.models);
+      }
       if (tool === "agy") {
-        agyDesktopProxy = await startAgyDesktopProxy(relay.baseUrl, localKey, model);
-        addAntigravityDesktopHook(plan, agyDesktopProxy.baseUrl);
+        agyDesktopProxy = await startAgyDesktopProxy(relay.baseUrl, localKey, model, undefined, catalog);
+        addAntigravityDesktopHook(plan, agyDesktopProxy.baseUrl, catalog);
       }
       writeDesktopLaunchPlan(plan);
       M2.info(`Starting ${tool} desktop with ${model} through ${serverUrl}. Profile: ${plan.profileDir}. Keep cr running until you close this app instance.`);
@@ -10498,17 +11068,19 @@ async function startCommand(options = {}) {
     return;
   }
   if (tool === "agy")
-    assertAgyGeminiMode(homedir13());
-  const recognizedModel = tool === "agy" ? registerAgyLaunchModel(homedir13(), model, discoverAgyTransportModel(options.executablePath || "agy", apiKey)) : undefined;
+    assertAgyGeminiMode(homedir14());
+  const recognizedModel = tool === "agy" ? registerAgyLaunchCatalog(homedir14(), catalog, discoverAgyTransportModel(options.executablePath || "agy", apiKey)) : undefined;
   if (recognizedModel)
     assertAgyCustomModel(options.executablePath || "agy", recognizedModel, apiKey);
-  const relay = await startLaunchProxy(serverUrl, apiKey, tool);
+  const relay = await startLaunchProxy(serverUrl, apiKey, tool, apiKey, catalog);
   let agyProxy;
   try {
-    agyProxy = tool === "agy" ? await startAgyModelProxy(relay.baseUrl, apiKey, model) : undefined;
-    const plan = buildLaunchPlan(tool, relay.baseUrl, apiKey, model, options.toolArgs, homedir13(), executablePath, agyProxy && recognizedModel ? { baseUrl: agyProxy.baseUrl, recognizedModel } : undefined);
+    agyProxy = tool === "agy" ? await startAgyModelProxy(relay.baseUrl, apiKey, model, catalog) : undefined;
+    const plan = buildLaunchPlan(tool, relay.baseUrl, apiKey, model, options.toolArgs, homedir14(), executablePath, agyProxy && recognizedModel ? { baseUrl: agyProxy.baseUrl, recognizedModel } : undefined, catalog);
     if (plan.configFile)
       writeOwnedConfig(plan.configFile);
+    for (const file of plan.extraFiles || [])
+      writeOwnedConfig(file);
     M2.info(`${import_picocolors12.default.green("Starting")} ${import_picocolors12.default.bold(TOOL_OPTIONS.find((option) => option.value === tool)?.label || tool)} with ${import_picocolors12.default.cyan(model)} through ${import_picocolors12.default.dim(serverUrl)}`);
     const exitCode = await runTool(plan);
     process.exitCode = exitCode;
@@ -10563,7 +11135,7 @@ process.on("warning", (warning) => {
   console.warn(warning.name, warning.message);
 });
 var program2 = new Command2;
-var cliVersion = JSON.parse(readFileSync13(new URL("../package.json", import.meta.url), "utf8")).version;
+var cliVersion = JSON.parse(readFileSync15(new URL("../package.json", import.meta.url), "utf8")).version;
 program2.name("closedrouter").description("ClosedRouter CLI: Import local AI subscriptions & API keys into your shared token pool").version(cliVersion).option("-s, --server <url>", "ClosedRouter server base URL (default: http://localhost:8000)").action(async (options) => {
   await onboardCommand({ server: options.server });
 });
@@ -10614,7 +11186,7 @@ program2.command("gateway").alias("daemon").alias("bridge").description("Start t
 program2.command("settings").description("Configure the CLI model selector").option("--model-grouping <grouping>", "Group models by model-provider, account-provider, or none").action(async (options) => {
   await settingsCommand({ modelGrouping: options.modelGrouping });
 });
-program2.command("start [tool] [tool-args...]").alias("launch").description("Configure and start a coding CLI or desktop app through ClosedRouter").option("--desktop", "Launch the desktop app for codex, claude, cursor, or antigravity").option("--open-only", "Open an isolated desktop app without gateway configuration").option("-s, --server <url>", "ClosedRouter server base URL").option("-k, --key <key>", "Platform API key; otherwise use the saved CLI key").option("-m, --model <model>", "Gateway model to use").option("--group-by <grouping>", "Override model grouping for this launch: model-provider, account-provider, or none").option("--path <path>", "Path to the installed CLI, desktop executable, or macOS app bundle").allowUnknownOption().action(async (tool, toolArgs, options) => {
+program2.command("start [tool] [tool-args...]").alias("launch").description("Configure and start a coding CLI or desktop app through ClosedRouter").option("--desktop", "Launch the desktop app for codex, claude, cursor, or antigravity").option("--open-only", "Open an isolated desktop app without gateway configuration").option("--desktop-inspector", "Enable Claude's startup hook using an installed shared Electron runtime").option("-s, --server <url>", "ClosedRouter server base URL").option("-k, --key <key>", "Platform API key; otherwise use the saved CLI key").option("-m, --model <model>", "Gateway model to use").option("--group-by <grouping>", "Override model grouping for this launch: model-provider, account-provider, or none").option("--path <path>", "Path to the installed CLI, desktop executable, or macOS app bundle").allowUnknownOption().action(async (tool, toolArgs, options) => {
   await startCommand({
     tool,
     toolArgs: toolArgs || [],
@@ -10624,7 +11196,8 @@ program2.command("start [tool] [tool-args...]").alias("launch").description("Con
     groupBy: options.groupBy,
     executablePath: options.path,
     desktop: options.desktop,
-    openOnly: options.openOnly
+    openOnly: options.openOnly,
+    desktopInspector: options.desktopInspector
   });
 });
 program2.parseAsync(process.argv).catch((error) => {