@codexhost/cli-darwin-x64 0.4.1 → 0.4.3

package/app/desktop-controller.mjs

@@ -285,270 +285,6 @@ var CdpClient = class _CdpClient {
   }
 };
 
-// packages/desktop-control/src/main-process-title-policy.ts
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function resultRecord(value, command) {
-  if (!isRecord2(value)) throw new Error(`${command} returned an invalid result`);
-  if (isRecord2(value.exceptionDetails)) {
-    const exception = value.exceptionDetails.exception;
-    const description = isRecord2(exception) ? exception.description : null;
-    const text = value.exceptionDetails.text;
-    throw new Error(
-      typeof description === "string" ? description : typeof text === "string" ? text : `${command} failed`
-    );
-  }
-  return value;
-}
-function remoteObjectId(value, label) {
-  if (!isRecord2(value) || typeof value.objectId !== "string") {
-    throw new Error(`${label} is unavailable`);
-  }
-  return value.objectId;
-}
-function properties(value, command) {
-  const result = resultRecord(value, command).result;
-  if (!Array.isArray(result)) throw new Error(`${command} returned invalid properties`);
-  return result.filter(isRecord2);
-}
-var ELECTRON_MODULE_EXPRESSION = `(() => {
-  const mainModule = process.mainModule;
-  if (mainModule != null && typeof mainModule.require === 'function') {
-    return mainModule.require('electron');
-  }
-  const { createRequire } = process.getBuiltinModule('module');
-  return createRequire(process.execPath)('electron');
-})()`;
-var CONNECT_APP_HOST_CHANNEL = "codex_desktop:connect-app-host";
-var POLICY_STATE_SYMBOL = "codexhost.main-process-title-policy.v1";
-var SERVICE_OWNER_SYMBOL = "codexhost.main-process-title-policy.owner.v1";
-var RENDERER_READY_EXPRESSION = "(() => { Object.defineProperty(window, '__codexhostMainProcessTitlePolicyV1', { configurable: true, value: { state: 'ready' } }); return 'ready'; })()";
-var INSTALL_POLICY_FUNCTION = `async function (rendererWebContentsId) {
-  const mainModule = process.mainModule;
-  const electron = mainModule != null && typeof mainModule.require === 'function'
-    ? mainModule.require('electron')
-    : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
-  const selected = electron.webContents.fromId(rendererWebContentsId);
-  if (selected == null || selected.isDestroyed() || selected.getType() !== 'window') {
-    throw new Error('Owned Renderer unavailable for title policy');
-  }
-
-  const context = this(selected);
-  if (context == null || typeof context.createAppHost !== 'function') {
-    throw new Error('WindowContext unavailable for title policy');
-  }
-  const stateSymbol = Symbol.for(${JSON.stringify(POLICY_STATE_SYMBOL)});
-  const ownerSymbol = Symbol.for(${JSON.stringify(SERVICE_OWNER_SYMBOL)});
-  globalThis[stateSymbol]?.dispose?.();
-
-  const originalCreateAppHost = context.createAppHost;
-  const sampleHost = originalCreateAppHost.call(context, selected);
-  const sampleService = sampleHost?.services?.threadMetadataGeneration;
-  const servicePrototype = sampleService == null ? null : Object.getPrototypeOf(sampleService);
-  const originalGenerateTitle = servicePrototype?.generateTitle;
-  if (
-    servicePrototype == null ||
-    typeof originalGenerateTitle !== 'function' ||
-    !Function.prototype.toString.call(originalGenerateTitle).includes('Failed to generate thread title')
-  ) {
-    throw new Error('ThreadMetadataGenerationService signature mismatch');
-  }
-  const counters = {
-    codexTitleCalls: 0,
-    piTitleSkips: 0,
-    externalTitleSkips: 0,
-    ambiguousTitleSkips: 0,
-  };
-  const ownedWebContentsIds = new Set();
-  const ownService = (service, contents) => {
-    const existingOwner = service[ownerSymbol];
-    if (existingOwner != null && existingOwner !== contents) {
-      throw new Error('Thread metadata service ownership mismatch');
-    }
-    if (existingOwner == null) {
-      Object.defineProperty(service, ownerSymbol, { value: contents });
-    }
-    ownedWebContentsIds.add(contents.id);
-  };
-  ownService(sampleService, selected);
-  const wrappedCreateAppHost = function (contents) {
-    const host = originalCreateAppHost.call(this, contents);
-    const service = host?.services?.threadMetadataGeneration;
-    if (service != null) ownService(service, contents);
-    return host;
-  };
-  const wrappedGenerateTitle = async function (params) {
-    const owner = this[ownerSymbol];
-    if (owner == null || owner.isDestroyed()) {
-      counters.ambiguousTitleSkips += 1;
-      return null;
-    }
-    let selection = null;
-    try {
-      selection = await owner.executeJavaScript(
-        "window.__codexhostRendererBindingProbeV1?.lockedSelection() ?? null",
-        true,
-      );
-    } catch {}
-    if (selection?.phase !== 'locked') {
-      counters.ambiguousTitleSkips += 1;
-      return null;
-    }
-    if (selection.agent === 'pi') {
-      counters.piTitleSkips += 1;
-      return null;
-    }
-    if (selection.agent !== 'codex') {
-      counters.externalTitleSkips += 1;
-      return null;
-    }
-    counters.codexTitleCalls += 1;
-    return originalGenerateTitle.call(this, params);
-  };
-
-  context.createAppHost = wrappedCreateAppHost;
-  servicePrototype.generateTitle = wrappedGenerateTitle;
-  const state = {
-    counters,
-    ownedWebContentsIds,
-    dispose() {
-      if (context.createAppHost === wrappedCreateAppHost) {
-        context.createAppHost = originalCreateAppHost;
-      }
-      if (servicePrototype.generateTitle === wrappedGenerateTitle) {
-        servicePrototype.generateTitle = originalGenerateTitle;
-      }
-      if (globalThis[stateSymbol] === state) delete globalThis[stateSymbol];
-    },
-  };
-  globalThis[stateSymbol] = state;
-  return {
-    state: 'ready',
-    reason: 'ready',
-    requiresRendererReload: true,
-  };
-}`;
-async function installMainProcessTitlePolicy(inspector, rendererWebContentsId) {
-  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
-    throw new Error("Renderer webContents ID must be a positive integer");
-  }
-  const listenerResponse = resultRecord(
-    await inspector.command("Runtime.evaluate", {
-      expression: `(${ELECTRON_MODULE_EXPRESSION}).ipcMain.listeners(${JSON.stringify(
-        CONNECT_APP_HOST_CHANNEL
-      )})[0]`
-    }),
-    "Runtime.evaluate"
-  );
-  const listener = listenerResponse.result;
-  const listenerId = remoteObjectId(listener, "connect-app-host listener");
-  const listenerProperties = resultRecord(
-    await inspector.command("Runtime.getProperties", { objectId: listenerId }),
-    "Runtime.getProperties"
-  );
-  const internalProperties = listenerProperties.internalProperties;
-  if (!Array.isArray(internalProperties)) {
-    throw new Error("connect-app-host listener scopes are unavailable");
-  }
-  const scopes = internalProperties.find(
-    (property) => isRecord2(property) && property.name === "[[Scopes]]"
-  );
-  const scopesId = remoteObjectId(
-    isRecord2(scopes) ? scopes.value : null,
-    "connect-app-host listener scopes"
-  );
-  const scopeProperties = properties(
-    await inspector.command("Runtime.getProperties", {
-      objectId: scopesId,
-      ownProperties: true
-    }),
-    "Runtime.getProperties"
-  );
-  const localScope = scopeProperties.find((property) => property.name === "0");
-  const localScopeId = remoteObjectId(localScope?.value, "connect-app-host local scope");
-  const localProperties = properties(
-    await inspector.command("Runtime.getProperties", {
-      objectId: localScopeId,
-      ownProperties: true
-    }),
-    "Runtime.getProperties"
-  );
-  const getContext = localProperties.find(
-    (property) => property.name === "f" && typeof property.value?.objectId === "string"
-  );
-  const getContextId = remoteObjectId(getContext?.value, "getContextForWebContents");
-  const installPromise = resultRecord(
-    await inspector.command("Runtime.callFunctionOn", {
-      objectId: getContextId,
-      functionDeclaration: INSTALL_POLICY_FUNCTION,
-      arguments: [{ value: rendererWebContentsId }]
-    }),
-    "Runtime.callFunctionOn"
-  );
-  const promiseObjectId = remoteObjectId(
-    installPromise.result,
-    "Main-process title policy installation promise"
-  );
-  const installResponse = resultRecord(
-    await inspector.command("Runtime.awaitPromise", {
-      promiseObjectId,
-      returnByValue: true
-    }),
-    "Runtime.awaitPromise"
-  );
-  const remoteResult = installResponse.result;
-  const value = isRecord2(remoteResult) ? remoteResult.value : null;
-  if (!isRecord2(value) || value.state !== "ready" || value.reason !== "ready" || value.requiresRendererReload !== true || Object.keys(value).length !== 3) {
-    throw new Error("Main-process title policy returned an invalid status");
-  }
-  return value;
-}
-async function markRendererTitlePolicyReady(inspector, rendererWebContentsId) {
-  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
-    throw new Error("Renderer webContents ID must be a positive integer");
-  }
-  const value = await inspector.evaluate(`(async () => {
-    const state = globalThis[Symbol.for(${JSON.stringify(POLICY_STATE_SYMBOL)})];
-    if (state == null) throw new Error('Main-process title policy is unavailable');
-    const mainModule = process.mainModule;
-    const electron = mainModule != null && typeof mainModule.require === 'function'
-      ? mainModule.require('electron')
-      : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
-    const selected = electron.webContents.fromId(${rendererWebContentsId});
-    if (selected == null || selected.isDestroyed() || selected.getType() !== 'window') {
-      throw new Error('Owned Renderer unavailable for title policy readiness');
-    }
-    if (!state.ownedWebContentsIds.has(selected.id)) {
-      throw new Error('Renderer metadata service ownership is unavailable');
-    }
-    const marker = selected.executeJavaScript(
-      ${JSON.stringify(RENDERER_READY_EXPRESSION)},
-      true,
-    );
-    const markerTimeout = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error('Renderer readiness marker timed out')), 2_000);
-    });
-    await Promise.race([marker, markerTimeout]);
-    return { state: 'ready', reason: 'owned-metadata-service' };
-  })()`);
-  if (!isRecord2(value) || value.state !== "ready" || value.reason !== "owned-metadata-service") {
-    throw new Error("Renderer title policy returned an invalid readiness status");
-  }
-  return value;
-}
-async function readMainProcessTitlePolicyCounters(inspector) {
-  const value = await inspector.evaluate(`(() => {
-    const state = globalThis[Symbol.for(${JSON.stringify(POLICY_STATE_SYMBOL)})];
-    return state == null ? null : { ...state.counters };
-  })()`);
-  if (value === null) return null;
-  if (!isRecord2(value) || !Number.isInteger(value.codexTitleCalls) || !Number.isInteger(value.piTitleSkips) || !Number.isInteger(value.externalTitleSkips) || !Number.isInteger(value.ambiguousTitleSkips)) {
-    throw new Error("Main-process title policy returned invalid counters");
-  }
-  return value;
-}
-
 // packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
 function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewarmedThreadManager) {
   const existing = target.__codexhostDraftPrewarmPolicyV1;
@@ -561,7 +297,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
   const originalOnNotification = manager.onNotification;
   const originalDispatchAppServerResponse = manager.dispatchAppServerResponse;
   let selectedModel = null;
-  const isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
   const isRemoteControlHost = hostId.startsWith("remote-control:");
   const knownExternalThreadIds = /* @__PURE__ */ new Set();
   const knownOfficialThreadIds = /* @__PURE__ */ new Set();
@@ -645,14 +381,14 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
     bridgeState = "idle";
   };
   const rememberExternalThread = (value) => {
-    if (!isRecord5(value) || typeof value.id !== "string") return;
+    if (!isRecord4(value) || typeof value.id !== "string") return;
     if (value.modelProvider === "codexhost" || value.cliVersion === "codexhost") {
       knownExternalThreadIds.add(value.id);
       knownOfficialThreadIds.delete(value.id);
     }
   };
   const observeBridgeResult = (request, result) => {
-    if (!request || !isRecord5(result)) return;
+    if (!request || !isRecord4(result)) return;
     if (request.method === "thread/list" && Array.isArray(result.data)) {
       for (const thread of result.data) rememberExternalThread(thread);
       return;
@@ -661,7 +397,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
       rememberExternalThread(result.thread);
       return;
     }
-    if (request.method === "codexhost/thread/inspect" && isRecord5(request.parameters) && typeof request.parameters.threadId === "string") {
+    if (request.method === "codexhost/thread/inspect" && isRecord4(request.parameters) && typeof request.parameters.threadId === "string") {
       if (result.owner === "external") {
         knownExternalThreadIds.add(request.parameters.threadId);
         knownOfficialThreadIds.delete(request.parameters.threadId);
@@ -671,18 +407,18 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
       }
       return;
     }
-    if (request.method === "thread/delete" && isRecord5(request.parameters) && typeof request.parameters.threadId === "string") {
+    if (request.method === "thread/delete" && isRecord4(request.parameters) && typeof request.parameters.threadId === "string") {
       knownExternalThreadIds.delete(request.parameters.threadId);
       knownOfficialThreadIds.delete(request.parameters.threadId);
     }
   };
   const handleBridgeFrame = (value) => {
-    if (!isRecord5(value)) {
+    if (!isRecord4(value)) {
       failBridge("received a non-object app-server frame");
       return;
     }
     if (value.method === bridgeReadyMethod && value.id === void 0) {
-      if (isRecord5(value.params) && value.params.protocolVersion === 1) {
+      if (isRecord4(value.params) && value.params.protocolVersion === 1) {
         bridgeState = "ready";
         if (bridgeReadyTimeout !== null) globalThis.clearTimeout(bridgeReadyTimeout);
         bridgeReadyTimeout = null;
@@ -695,7 +431,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
       return;
     }
     if (typeof value.method === "string" && value.id === void 0) {
-      if (value.method === "thread/started" && isRecord5(value.params)) {
+      if (value.method === "thread/started" && isRecord4(value.params)) {
         rememberExternalThread(value.params.thread);
       }
       originalOnNotification.call(manager, value.method, value.params);
@@ -746,7 +482,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
     }
   };
   const handleOuterNotification = (method, parameters) => {
-    if (method === "process/exited" && isRecord5(parameters) && parameters.processHandle === bridgeProcessHandle) {
+    if (method === "process/exited" && isRecord4(parameters) && parameters.processHandle === bridgeProcessHandle) {
       const exitCode = typeof parameters.exitCode === "number" ? parameters.exitCode : "unknown";
       const stderr = typeof parameters.stderr === "string" ? parameters.stderr.trim() : "";
       failBridge(
@@ -755,7 +491,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
       );
       return true;
     }
-    if (method !== "process/outputDelta" || !isRecord5(parameters) || parameters.processHandle !== bridgeProcessHandle || parameters.stream !== "stdout" && parameters.stream !== "stderr" || typeof parameters.deltaBase64 !== "string") {
+    if (method !== "process/outputDelta" || !isRecord4(parameters) || parameters.processHandle !== bridgeProcessHandle || parameters.stream !== "stdout" && parameters.stream !== "stderr" || typeof parameters.deltaBase64 !== "string") {
       return false;
     }
     if (parameters.capReached === true) {
@@ -860,7 +596,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
     return bridgeInitialization;
   };
   const threadIdFromParameters = (parameters) => {
-    if (!isRecord5(parameters)) return null;
+    if (!isRecord4(parameters)) return null;
     const value = parameters.threadId ?? parameters.conversationId;
     return typeof value === "string" ? value : null;
   };
@@ -875,9 +611,9 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
         threadIds: [threadId]
       })
     ).then((value) => {
-      const ownerships = isRecord5(value) && Array.isArray(value.threads) ? value.threads : null;
+      const ownerships = isRecord4(value) && Array.isArray(value.threads) ? value.threads : null;
       const ownership = ownerships?.[0];
-      if (!ownerships || !isRecord5(ownership) || ownerships.length !== 1 || ownership.threadId !== threadId || ownership.owner !== "external" && ownership.owner !== "codex") {
+      if (!ownerships || !isRecord4(ownership) || ownerships.length !== 1 || ownership.threadId !== threadId || ownership.owner !== "external" && ownership.owner !== "codex") {
         throw transportError("Thread ownership lookup returned an invalid result");
       }
       if (ownership.owner === "external") {
@@ -913,7 +649,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
     if (method.startsWith("codexhost/")) return true;
     if (method === "thread/list") return true;
     if (method === "thread/start") {
-      return isRecord5(parameters) && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
+      return isRecord4(parameters) && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
     }
     const threadId = threadIdFromParameters(parameters);
     if (threadId && knownExternalThreadIds.has(threadId)) return true;
@@ -921,7 +657,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
     return selectedModel !== null && (method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/"));
   };
   const routeThreadStart = (parameters) => {
-    if (selectedModel === null || !isRecord5(parameters) || parameters.ephemeral === true) {
+    if (selectedModel === null || !isRecord4(parameters) || parameters.ephemeral === true) {
       return parameters;
     }
     return { ...parameters, model: selectedModel };
@@ -951,7 +687,7 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
   bridge.prewarmThreadStart = routedPrewarm;
   const routedWindowMessage = (event) => {
     const message = event.data;
-    if (!isRecord5(message) || message.type !== "mcp-notification" || message.hostId !== hostId || typeof message.method !== "string") {
+    if (!isRecord4(message) || message.type !== "mcp-notification" || message.hostId !== hostId || typeof message.method !== "string") {
       return;
     }
     handleOuterNotification(message.method, message.params);
@@ -1041,63 +777,6 @@ function installDraftPrewarmPolicyBridge(manager, bridge, hostId, target, prewar
   }
   return { state: "ready", reason: "owned-request-bridge" };
 }
-async function installDraftPrewarmPolicyInRenderer(contents, findRequestManagerExpression, installRendererPolicyFunction) {
-  if (contents === null || contents.isDestroyed() || contents.getType() !== "window") {
-    throw new Error("Owned Renderer is unavailable for draft prewarm policy");
-  }
-  let attachedHere = false;
-  try {
-    if (!contents.debugger.isAttached()) {
-      contents.debugger.attach("1.3");
-      attachedHere = true;
-    }
-    await contents.debugger.sendCommand("Runtime.enable");
-    const managerResult = await contents.debugger.sendCommand("Runtime.evaluate", {
-      expression: findRequestManagerExpression
-    });
-    const managerResultId = managerResult.result?.objectId;
-    if (typeof managerResultId !== "string") {
-      throw new Error("Renderer request manager inspection failed");
-    }
-    const managerProperties = await contents.debugger.sendCommand("Runtime.getProperties", {
-      objectId: managerResultId,
-      ownProperties: true
-    });
-    const candidateCount = managerProperties.result?.find(
-      (property) => property.name === "candidateCount"
-    )?.value?.value;
-    const hostId = managerProperties.result?.find((property) => property.name === "hostId")?.value?.value;
-    const manager = managerProperties.result?.find(
-      (property) => property.name === "manager"
-    )?.value;
-    const requestClient = managerProperties.result?.find(
-      (property) => property.name === "requestClient"
-    )?.value;
-    const prewarmedThreadManager = managerProperties.result?.find(
-      (property) => property.name === "prewarmedThreadManager"
-    )?.value;
-    if (candidateCount !== 1 || typeof hostId !== "string" || hostId.length === 0 || typeof manager?.objectId !== "string" || typeof requestClient?.objectId !== "string") {
-      throw new Error("Renderer request manager is ambiguous");
-    }
-    if (typeof prewarmedThreadManager?.objectId !== "string") {
-      throw new Error("Renderer prewarmed Thread manager is unavailable");
-    }
-    const installed = await contents.debugger.sendCommand("Runtime.callFunctionOn", {
-      objectId: manager.objectId,
-      functionDeclaration: installRendererPolicyFunction,
-      arguments: [
-        { objectId: requestClient.objectId },
-        { value: hostId },
-        { objectId: prewarmedThreadManager.objectId }
-      ],
-      awaitPromise: true,
-      returnByValue: true
-    });
-    return installed.result?.value;
-  } finally {
-    if (attachedHere && contents.debugger.isAttached()) contents.debugger.detach();
-  }
-}
 
 // packages/desktop-control/src/renderer-draft-prewarm-policy.ts
 function selectRendererRequestManager(candidates, activeHostIds) {
@@ -1113,7 +792,7 @@ function selectRendererRequestManager(candidates, activeHostIds) {
   );
   return eligible.length === 1 ? eligible[0] ?? null : null;
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var FIND_REQUEST_MANAGER_EXPRESSION = `(() => {
@@ -1193,30 +872,36 @@ var INSTALL_RENDERER_POLICY_FUNCTION = `function(requestClient, hostId, prewarme
 }`;
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
-function mainProcessInstaller(rendererWebContentsId) {
-  return `async function () {
-    const mainModule = process.mainModule;
-    const electron = mainModule != null && typeof mainModule.require === 'function'
-      ? mainModule.require('electron')
-      : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
-    const contents = electron.webContents.fromId(${rendererWebContentsId});
-    return (${installDraftPrewarmPolicyInRenderer.toString()})(
-      contents,
-      ${JSON.stringify(FIND_REQUEST_MANAGER_EXPRESSION)},
-      ${JSON.stringify(INSTALL_RENDERER_POLICY_FUNCTION)}
+function directRendererInstaller() {
+  return `(async () => {
+    const selected = ${FIND_REQUEST_MANAGER_EXPRESSION};
+    if (
+      selected.candidateCount !== 1 ||
+      typeof selected.hostId !== 'string' ||
+      selected.hostId.length === 0 ||
+      selected.manager == null ||
+      selected.requestClient == null
+    ) {
+      throw new Error('Renderer request manager is ambiguous');
+    }
+    if (selected.prewarmedThreadManager == null) {
+      throw new Error('Renderer prewarmed Thread manager is unavailable');
+    }
+    return (${installDraftPrewarmPolicyBridge.toString()})(
+      selected.manager,
+      selected.requestClient,
+      selected.hostId,
+      window,
+      selected.prewarmedThreadManager,
     );
-  }`;
+  })()`;
 }
-async function installRendererDraftPrewarmPolicy(inspector, rendererWebContentsId) {
-  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
-    throw new Error("Renderer webContents ID must be a positive integer");
-  }
-  const installer = mainProcessInstaller(rendererWebContentsId);
+async function waitForDraftPrewarmPolicy(evaluate, expression) {
   const deadline = Date.now() + REQUEST_MANAGER_WAIT_TIMEOUT_MS;
   while (true) {
     try {
-      const value = await inspector.evaluate(`(${installer})()`);
-      if (!isRecord3(value) || value.state !== "ready" || value.reason !== "owned-request-bridge") {
+      const value = await evaluate(expression);
+      if (!isRecord2(value) || value.state !== "ready" || value.reason !== "owned-request-bridge") {
         throw new Error("Renderer draft prewarm policy returned an invalid status");
       }
       return value;
@@ -1230,9 +915,15 @@ async function installRendererDraftPrewarmPolicy(inspector, rendererWebContentsI
     }
   }
 }
+function installRendererDraftPrewarmPolicyDirect(renderer) {
+  return waitForDraftPrewarmPolicy(
+    (expression) => renderer.evaluate(expression),
+    directRendererInstaller()
+  );
+}
 
-// packages/desktop-control/src/renderer-control-session.ts
-function isRecord4(value) {
+// packages/desktop-control/src/renderer-cdp-control-session.ts
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sleep(milliseconds) {
@@ -1241,6 +932,20 @@ function sleep(milliseconds) {
 function sameAgents(actual, expected) {
   return actual.length === expected.length && actual.every((agent, index) => agent === expected[index]);
 }
+function isPrimaryRendererUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "app:" && url.hostname === "-" && url.pathname === "/index.html" && url.search === "" && url.hash === "";
+  } catch {
+    return false;
+  }
+}
+function selectPrimaryRendererTarget(targets, preferredTargetId) {
+  const candidates = targets.filter(
+    (target) => target.type === "page" && isPrimaryRendererUrl(target.url)
+  );
+  return candidates.find((target) => target.id === preferredTargetId) ?? candidates.at(0) ?? null;
+}
 var RendererAdapterReadinessError = class extends Error {
   constructor(state, reason) {
     super(`Production Renderer Adapter is ${state}: ${reason}`);
@@ -1252,7 +957,7 @@ var RendererAdapterReadinessError = class extends Error {
   reason;
 };
 function validateBindingStatus(value, expectedAgents) {
-  if (!isRecord4(value) || value.version !== 2 || !Array.isArray(value.enabledAgents) || value.enabledAgents.some((agent) => typeof agent !== "string") || !sameAgents(value.enabledAgents, expectedAgents) || !isRecord4(value.adapter)) {
+  if (!isRecord3(value) || value.version !== 2 || !Array.isArray(value.enabledAgents) || value.enabledAgents.some((agent) => typeof agent !== "string") || !sameAgents(value.enabledAgents, expectedAgents) || !isRecord3(value.adapter)) {
     throw new Error("Production Renderer binding returned an invalid status");
   }
   if (value.adapter.state !== "ready" || typeof value.adapter.reason !== "string") {
@@ -1262,161 +967,45 @@ function validateBindingStatus(value, expectedAgents) {
   }
   return value;
 }
-function selectRendererWebContents(contents, preferredRendererId) {
-  const candidates = contents.filter(
-    (item) => item.type === "window" && item.surface === "primary" && item.runtime.available && item.runtime.elementCount !== null
-  ).toSorted(
-    (left, right) => (right.runtime.elementCount ?? 0) - (left.runtime.elementCount ?? 0)
-  );
-  const preferred = candidates.find(
-    (candidate) => candidate.id === preferredRendererId && (candidate.runtime.elementCount ?? 0) > 0
-  );
-  if (preferred) return preferred;
-  return candidates.find((candidate) => (candidate.runtime.elementCount ?? 0) > 0) ?? null;
-}
-async function waitForRendererTitlePolicyReady(markReadiness, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  const pollIntervalMs = options.pollIntervalMs ?? 250;
-  const now = options.now ?? Date.now;
-  const wait = options.sleep ?? sleep;
-  const deadline = now() + timeoutMs;
-  let lastError;
-  while (now() < deadline) {
-    try {
-      return await markReadiness();
-    } catch (error) {
-      lastError = error;
-    }
-    await wait(pollIntervalMs);
-  }
-  const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
-  throw new Error(`Renderer title policy ownership did not become ready${detail}`);
-}
-async function waitForInspectorTarget(endpoint, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  const pollIntervalMs = options.pollIntervalMs ?? 250;
+async function waitForPrimaryTarget(endpoint, operations, timeoutMs, pollIntervalMs, preferredTargetId) {
   const deadline = Date.now() + timeoutMs;
   let lastError;
   while (Date.now() < deadline) {
     try {
-      const targets = await listCdpTargets(endpoint, options.fetchImpl);
-      const inspector = targets.find((target) => target.type === "node");
-      if (inspector) return inspector;
-      lastError = new Error("Inspector has no Node target");
+      const target = selectPrimaryRendererTarget(
+        await operations.listTargets(endpoint),
+        preferredTargetId
+      );
+      if (target) return target;
+      lastError = new Error("Renderer CDP has no primary app://-/index.html page target");
     } catch (error) {
       lastError = error;
     }
     await sleep(pollIntervalMs);
   }
   const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
-  throw new Error(`Electron main-process Inspector did not become ready${detail}`);
+  throw new Error(`Primary Codex Renderer CDP target did not become ready${detail}`);
 }
-var electronModuleExpression = `(() => {
-  const mainModule = process.mainModule;
-  if (mainModule != null && typeof mainModule.require === 'function') {
-    return mainModule.require('electron');
-  }
-  const { createRequire } = process.getBuiltinModule('module');
-  return createRequire(process.execPath)('electron');
-})()`;
-var webContentsRuntimeExpression = "(() => ({ elementCount: document.querySelectorAll('*').length }))()";
-async function inspectElectronWebContents(inspector) {
-  const value = await inspector.evaluate(`(async () => {
-    const { webContents } = ${electronModuleExpression};
-    const result = await Promise.all(webContents.getAllWebContents().map(async (contents) => {
-      let runtime = { available: false, elementCount: null };
-      try {
-        const evaluation = contents.executeJavaScript(${JSON.stringify(webContentsRuntimeExpression)}, true);
-        const timeout = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error('Renderer inspection timed out')), 2_000);
-        });
-        runtime = { available: true, ...(await Promise.race([evaluation, timeout])) };
-      } catch {}
-      return {
-        id: contents.id,
-        type: contents.getType(),
-        surface: contents.getURL().includes('avatar-overlay') ? 'overlay' : 'primary',
-        runtime,
-      };
-    }));
-    return result;
-  })()`);
-  if (!Array.isArray(value)) throw new Error("Electron webContents inspection returned an array");
-  return value.map((item) => {
-    if (!isRecord4(item) || !Number.isInteger(item.id) || typeof item.type !== "string" || !["primary", "overlay"].includes(String(item.surface)) || !isRecord4(item.runtime)) {
-      throw new Error("Electron webContents inspection returned an invalid item");
-    }
-    return {
-      id: item.id,
-      type: item.type,
-      surface: item.surface,
-      runtime: {
-        available: item.runtime.available === true,
-        elementCount: Number.isInteger(item.runtime.elementCount) ? item.runtime.elementCount : null
-      }
-    };
+async function evaluateSource(renderer, source) {
+  const response = await renderer.command("Runtime.evaluate", {
+    expression: source,
+    awaitPromise: true
   });
-}
-async function activateElectronDesktop(inspector) {
-  const value = await inspector.evaluate(`(() => {
-    const { BrowserWindow } = ${electronModuleExpression};
-    const windows = BrowserWindow.getAllWindows().filter((window) => !window.isDestroyed());
-    for (const window of windows) {
-      if (window.isMinimized()) window.restore();
-      window.show();
-      window.focus();
-    }
-    return windows.length;
-  })()`);
-  if (!Number.isInteger(value) || value < 1) {
-    throw new Error("Electron Desktop activation found no live window");
+  if (!isRecord3(response)) throw new Error("Renderer source evaluation returned an invalid result");
+  if (isRecord3(response.exceptionDetails)) {
+    const text = typeof response.exceptionDetails.text === "string" ? response.exceptionDetails.text : "Renderer source evaluation failed";
+    throw new Error(text);
   }
-  return value;
-}
-async function executeInWebContents(inspector, rendererWebContentsId, source) {
-  return inspector.evaluate(`(async () => {
-    const { webContents } = ${electronModuleExpression};
-    const contents = webContents.fromId(${rendererWebContentsId});
-    if (contents == null || contents.isDestroyed()) throw new Error('Renderer webContents is unavailable');
-    const result = await contents.executeJavaScript(${JSON.stringify(source)}, true);
-    return result === undefined ? null : result;
-  })()`);
 }
-async function reloadRenderer(inspector, rendererWebContentsId) {
-  await executeInWebContents(inspector, rendererWebContentsId, "location.reload(); null");
-}
-var defaultOperations = {
-  inspect: inspectElectronWebContents,
-  installTitlePolicy: installMainProcessTitlePolicy,
-  markTitlePolicyReady: markRendererTitlePolicyReady,
-  installDraftPrewarmPolicy: installRendererDraftPrewarmPolicy,
-  reload: reloadRenderer,
-  execute: executeInWebContents,
-  readBinding: (inspector, rendererWebContentsId) => executeInWebContents(
-    inspector,
-    rendererWebContentsId,
-    "window.__codexhostRendererBindingProbeV1?.status() ?? null"
-  ),
-  readTitlePolicyCounters: readMainProcessTitlePolicyCounters
-};
-async function waitForRenderer(inspector, operations, timeoutMs, pollIntervalMs, preferredRendererId) {
-  const deadline = Date.now() + timeoutMs;
-  let candidateCount = 0;
-  while (Date.now() < deadline) {
-    const inventory = await operations.inspect(inspector);
-    candidateCount = inventory.length;
-    const renderer = selectRendererWebContents(inventory, preferredRendererId);
-    if (renderer) return renderer;
-    await sleep(pollIntervalMs);
-  }
-  throw new Error(`Inspector did not find a live Electron Renderer (${candidateCount} seen)`);
+async function readBinding(renderer) {
+  return renderer.evaluate("window.__codexhostRendererBindingProbeV1?.status() ?? null");
 }
-async function waitForBinding(inspector, operations, rendererWebContentsId, enabledAgents, timeoutMs, pollIntervalMs) {
+async function waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs) {
   const deadline = Date.now() + timeoutMs;
   let lastError;
   while (Date.now() < deadline) {
     try {
-      const value = await operations.readBinding(inspector, rendererWebContentsId);
+      const value = await readBinding(renderer);
       if (value !== null) return validateBindingStatus(value, enabledAgents);
     } catch (error) {
       lastError = error;
@@ -1429,218 +1018,163 @@ async function waitForBinding(inspector, operations, rendererWebContentsId, enab
   const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
   throw new Error(`Production Renderer binding did not become ready${detail}`);
 }
-var InstalledRendererControlSession = class {
-  constructor(inspector, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, snapshot) {
-    this.inspector = inspector;
+async function installTarget(target, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations) {
+  const renderer = await operations.connect(target.webSocketDebuggerUrl);
+  try {
+    await renderer.command("Runtime.enable");
+    await renderer.command("Page.enable");
+    await renderer.command("Page.addScriptToEvaluateOnNewDocument", { source: rendererSource });
+    await evaluateSource(renderer, rendererSource);
+    const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(renderer);
+    const binding = await waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs);
+    return { renderer, snapshot: { target, draftPrewarmPolicy, binding } };
+  } catch (error) {
+    renderer.close();
+    throw error;
+  }
+}
+var InstalledRendererCdpControlSession = class {
+  constructor(renderer, rendererCdpEndpoint2, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot) {
+    this.renderer = renderer;
+    this.rendererCdpEndpoint = rendererCdpEndpoint2;
     this.rendererSource = rendererSource;
     this.enabledAgents = enabledAgents;
     this.timeoutMs = timeoutMs;
     this.pollIntervalMs = pollIntervalMs;
     this.operations = operations;
-    this.#snapshot = snapshot;
+    this.currentSnapshot = currentSnapshot;
   }
-  inspector;
+  renderer;
+  rendererCdpEndpoint;
   rendererSource;
   enabledAgents;
   timeoutMs;
   pollIntervalMs;
   operations;
+  currentSnapshot;
   #closed = false;
-  #snapshot;
   get snapshot() {
-    return this.#snapshot;
+    return this.currentSnapshot;
   }
   async ensureInstalled() {
-    if (this.#closed) throw new Error("Renderer Control Session is closed");
-    const selected = await waitForRenderer(
-      this.inspector,
+    if (this.#closed) throw new Error("Renderer CDP Control Session is closed");
+    const target = await waitForPrimaryTarget(
+      this.rendererCdpEndpoint,
       this.operations,
       this.timeoutMs,
       this.pollIntervalMs,
-      this.#snapshot.renderer.id
+      this.currentSnapshot.target.id
     );
-    const existing = await this.operations.readBinding(this.inspector, selected.id).catch(() => null);
-    if (existing !== null) {
-      const draftPrewarmPolicy2 = await this.operations.installDraftPrewarmPolicy(
-        this.inspector,
-        selected.id
+    if (target.id !== this.currentSnapshot.target.id) {
+      const replacement = await installTarget(
+        target,
+        this.rendererSource,
+        this.enabledAgents,
+        this.timeoutMs,
+        this.pollIntervalMs,
+        this.operations
       );
-      let binding2;
-      try {
-        binding2 = validateBindingStatus(existing, this.enabledAgents);
-      } catch (error) {
-        if (!(error instanceof RendererAdapterReadinessError)) throw error;
-        await this.operations.execute(this.inspector, selected.id, this.rendererSource);
-        binding2 = await waitForBinding(
-          this.inspector,
-          this.operations,
-          selected.id,
-          this.enabledAgents,
-          this.timeoutMs,
-          this.pollIntervalMs
-        );
-      }
-      this.#snapshot = {
-        ...this.#snapshot,
-        renderer: selected,
-        draftPrewarmPolicy: draftPrewarmPolicy2,
-        binding: binding2
-      };
-      return this.#snapshot;
+      this.renderer.close();
+      this.renderer = replacement.renderer;
+      this.currentSnapshot = replacement.snapshot;
+      return this.currentSnapshot;
+    }
+    try {
+      const existing = await readBinding(this.renderer);
+      if (existing === null) await evaluateSource(this.renderer, this.rendererSource);
+      else validateBindingStatus(existing, this.enabledAgents);
+      const draftPrewarmPolicy = await this.operations.installDraftPrewarmPolicy(this.renderer);
+      const binding = await waitForBinding(
+        this.renderer,
+        this.enabledAgents,
+        this.timeoutMs,
+        this.pollIntervalMs
+      );
+      this.currentSnapshot = { target, draftPrewarmPolicy, binding };
+      return this.currentSnapshot;
+    } catch {
+      const replacement = await installTarget(
+        target,
+        this.rendererSource,
+        this.enabledAgents,
+        this.timeoutMs,
+        this.pollIntervalMs,
+        this.operations
+      );
+      this.renderer.close();
+      this.renderer = replacement.renderer;
+      this.currentSnapshot = replacement.snapshot;
+      return this.currentSnapshot;
     }
-    const titlePolicyReadiness = await waitForRendererTitlePolicyReady(
-      () => this.operations.markTitlePolicyReady(this.inspector, selected.id),
-      { timeoutMs: this.timeoutMs, pollIntervalMs: this.pollIntervalMs }
-    );
-    await activateElectronDesktop(this.inspector);
-    await this.operations.execute(this.inspector, selected.id, this.rendererSource);
-    const draftPrewarmPolicy = await this.operations.installDraftPrewarmPolicy(
-      this.inspector,
-      selected.id
-    );
-    const binding = await waitForBinding(
-      this.inspector,
-      this.operations,
-      selected.id,
-      this.enabledAgents,
-      this.timeoutMs,
-      this.pollIntervalMs
-    );
-    this.#snapshot = {
-      ...this.#snapshot,
-      renderer: selected,
-      titlePolicyReadiness,
-      draftPrewarmPolicy,
-      binding
-    };
-    return this.#snapshot;
   }
-  activateDesktop() {
-    if (this.#closed) return Promise.reject(new Error("Renderer Control Session is closed"));
-    return activateElectronDesktop(this.inspector);
+  async activateDesktop() {
+    if (this.#closed) throw new Error("Renderer CDP Control Session is closed");
+    await this.renderer.command("Page.bringToFront");
+    return 1;
   }
   executeRenderer(expression) {
-    if (this.#closed) return Promise.reject(new Error("Renderer Control Session is closed"));
-    return this.operations.execute(
-      this.inspector,
-      this.#snapshot.renderer.id,
-      expression
-    );
-  }
-  readTitlePolicyCounters() {
-    if (this.#closed) return Promise.reject(new Error("Renderer Control Session is closed"));
-    return this.operations.readTitlePolicyCounters(this.inspector);
+    if (this.#closed) return Promise.reject(new Error("Renderer CDP Control Session is closed"));
+    return this.renderer.evaluate(expression);
   }
   close() {
     if (this.#closed) return;
     this.#closed = true;
-    this.inspector.close();
+    this.renderer.close();
   }
 };
-var startupTraceStartedAt = Date.now();
-function startupTrace(stage) {
-  if (process.env.CODEXHOST_STARTUP_TRACE !== "1") return;
-  console.error(
-    `[codexhost startup +${Date.now() - startupTraceStartedAt}ms] renderer-session: ${stage}`
-  );
-}
-async function createRendererControlSession(options) {
+var defaultOperations = {
+  listTargets: (endpoint) => listCdpTargets(endpoint),
+  connect: (webSocketDebuggerUrl) => CdpClient.connect(webSocketDebuggerUrl),
+  installDraftPrewarmPolicy: installRendererDraftPrewarmPolicyDirect
+};
+async function createRendererCdpControlSession(options) {
   const enabledAgents = options.enabledAgents ?? ["codex", "pi"];
   const timeoutMs = options.timeoutMs ?? 3e4;
   const pollIntervalMs = options.pollIntervalMs ?? 250;
   const operations = options.operations ?? defaultOperations;
-  startupTrace("waiting for initial Renderer");
-  const initial = await waitForRenderer(options.inspector, operations, timeoutMs, pollIntervalMs);
-  startupTrace("installing title policy");
-  const titlePolicy = await operations.installTitlePolicy(options.inspector, initial.id);
-  startupTrace("reloading Renderer");
-  await operations.reload(options.inspector, initial.id);
-  startupTrace("waiting for reloaded Renderer");
-  const selected = await waitForRenderer(
-    options.inspector,
+  const target = await waitForPrimaryTarget(
+    options.rendererCdpEndpoint,
     operations,
     timeoutMs,
-    pollIntervalMs,
-    initial.id
-  );
-  startupTrace("waiting for title policy readiness");
-  const titlePolicyReadiness = await waitForRendererTitlePolicyReady(
-    () => operations.markTitlePolicyReady(options.inspector, selected.id),
-    {
-      timeoutMs,
-      pollIntervalMs
-    }
-  );
-  startupTrace("injecting Renderer bundle");
-  await operations.execute(options.inspector, selected.id, options.rendererSource);
-  startupTrace("installing draft routing policy");
-  const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(
-    options.inspector,
-    selected.id
+    pollIntervalMs
   );
-  startupTrace("waiting for Renderer binding");
-  const binding = await waitForBinding(
-    options.inspector,
-    operations,
-    selected.id,
+  const installed = await installTarget(
+    target,
+    options.rendererSource,
     enabledAgents,
     timeoutMs,
-    pollIntervalMs
+    pollIntervalMs,
+    operations
   );
-  return new InstalledRendererControlSession(
-    options.inspector,
+  return new InstalledRendererCdpControlSession(
+    installed.renderer,
+    options.rendererCdpEndpoint,
     options.rendererSource,
     enabledAgents,
     timeoutMs,
     pollIntervalMs,
     operations,
-    {
-      renderer: selected,
-      titlePolicy,
-      titlePolicyReadiness,
-      draftPrewarmPolicy,
-      binding
-    }
+    installed.snapshot
   );
 }
-async function installRendererControlSession(options) {
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  const pollIntervalMs = options.pollIntervalMs ?? 250;
-  startupTrace("waiting for Electron Inspector target");
-  const target = await waitForInspectorTarget(options.inspectorEndpoint, {
-    timeoutMs,
-    pollIntervalMs
-  });
-  startupTrace("connecting to Electron Inspector");
-  const inspector = await CdpClient.connect(target.webSocketDebuggerUrl);
-  try {
-    startupTrace("enabling Inspector Runtime domain");
-    await inspector.command("Runtime.enable");
-    return await createRendererControlSession({
-      ...options,
-      inspector,
-      timeoutMs,
-      pollIntervalMs
-    });
-  } catch (error) {
-    inspector.close();
-    throw error;
-  }
+function installRendererCdpControlSession(options) {
+  return createRendererCdpControlSession(options);
 }
 
 // packages/desktop-control/src/production-controller.ts
 var PRODUCTION_INSTALL_TIMEOUT_MS = 9e4;
+var RENDERER_CSP_BOOTSTRAP = "globalThis.__zod_globalConfig ??= {}; globalThis.__zod_globalConfig.jitless = true;";
 var DESKTOP_CONTROLLER_READINESS_MAX_BYTES = 512;
 var TRANSIENT_INSTALL_ATTEMPTS = 3;
 var TRANSIENT_INSTALL_RETRY_MS = 250;
 var RECOVERY_RETRY_INITIAL_MS = 3e4;
 var RECOVERY_RETRY_MAX_MS = 3e5;
-var startupTraceStartedAt2 = Date.now();
-function startupTrace2(stage, detail) {
+var startupTraceStartedAt = Date.now();
+function startupTrace(stage, detail) {
   if (process.env.CODEXHOST_STARTUP_TRACE !== "1") return;
   const suffix = detail === void 0 ? "" : `: ${detail instanceof Error ? detail.message : String(detail)}`;
   console.error(
-    `[codexhost startup +${Date.now() - startupTraceStartedAt2}ms] controller: ${stage}${suffix}`
+    `[codexhost startup +${Date.now() - startupTraceStartedAt}ms] controller: ${stage}${suffix}`
   );
 }
 function serializeDesktopControllerReadiness(readiness) {
@@ -1655,7 +1189,7 @@ function serializeDesktopControllerReadiness(readiness) {
 }
 var defaultDependencies = {
   readRenderer: (filePath) => readFile(filePath, "utf8"),
-  install: installRendererControlSession,
+  install: installRendererCdpControlSession,
   startAttachmentServer: startControllerAttachmentServer,
   ready: (readiness) => {
     process.stdout.write(`${serializeDesktopControllerReadiness(readiness)}
@@ -1664,10 +1198,10 @@ var defaultDependencies = {
   sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
   monitorIntervalMs: 500
 };
-function inspectorEndpoint(value) {
+function rendererCdpEndpoint(value) {
   const url = new URL(value);
   if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) || !url.port || url.username || url.password || url.pathname !== "/" && url.pathname !== "" || url.search || url.hash) {
-    throw new Error("--inspector-endpoint must be a loopback HTTP origin with an explicit port");
+    throw new Error("--renderer-cdp-endpoint must be a loopback HTTP origin with an explicit port");
   }
   return url.origin;
 }
@@ -1680,10 +1214,12 @@ function parseDesktopControllerArguments(arguments_) {
   for (let index = 0; index < arguments_.length; index += 1) {
     const argument = arguments_[index];
     const value = arguments_[index + 1];
-    if (argument === "--inspector-endpoint") {
-      if (endpoint !== void 0) throw new Error("--inspector-endpoint may only be provided once");
-      if (!value) throw new Error("--inspector-endpoint requires a value");
-      endpoint = inspectorEndpoint(value);
+    if (argument === "--renderer-cdp-endpoint") {
+      if (endpoint !== void 0) {
+        throw new Error("--renderer-cdp-endpoint may only be provided once");
+      }
+      if (!value) throw new Error("--renderer-cdp-endpoint requires a value");
+      endpoint = rendererCdpEndpoint(value);
       index += 1;
       continue;
     }
@@ -1729,20 +1265,20 @@ function parseDesktopControllerArguments(arguments_) {
     }
     throw new Error(`unknown Desktop Controller option: ${argument}`);
   }
-  if (endpoint === void 0) throw new Error("--inspector-endpoint is required");
+  if (endpoint === void 0) throw new Error("--renderer-cdp-endpoint is required");
   if (rendererPath === void 0) throw new Error("--renderer is required");
   if (defaultAgent === void 0) throw new Error("--default-agent is required");
   if (attachmentPort === void 0) throw new Error("--attachment-port is required");
   if (attachmentNonce === void 0) throw new Error("--attachment-nonce is required");
   return {
-    inspectorEndpoint: endpoint,
+    rendererCdpEndpoint: endpoint,
     rendererPath,
     defaultAgent,
     attachmentPort,
     attachmentNonce
   };
 }
-function isTransientElectronInstallError(error) {
+function isTransientRendererInstallError(error) {
   let current = error;
   for (let depth = 0; depth < 4; depth += 1) {
     const message = current instanceof Error ? current.message : String(current);
@@ -1759,7 +1295,7 @@ async function installProductionSession(options, dependencies) {
     try {
       return await dependencies.install(options);
     } catch (error) {
-      if (attempt === TRANSIENT_INSTALL_ATTEMPTS || !isTransientElectronInstallError(error)) {
+      if (attempt === TRANSIENT_INSTALL_ATTEMPTS || !isTransientRendererInstallError(error)) {
         throw error;
       }
       await dependencies.sleep(TRANSIENT_INSTALL_RETRY_MS);
@@ -1782,14 +1318,15 @@ async function runDesktopController(options, signal, dependencies = defaultDepen
     recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
   };
   const createSession = async () => {
-    startupTrace2("reading Renderer bundle");
+    startupTrace("reading Renderer bundle");
     const rendererSource = await dependencies.readRenderer(options.rendererPath);
     if (rendererSource.trim().length === 0) throw new Error("production Renderer Bundle is empty");
-    startupTrace2("installing Renderer Session");
+    startupTrace("installing Renderer Session");
     const installed = await installProductionSession(
       {
-        inspectorEndpoint: options.inspectorEndpoint,
-        rendererSource: `${configuration}
+        rendererCdpEndpoint: options.rendererCdpEndpoint,
+        rendererSource: `${RENDERER_CSP_BOOTSTRAP}
+${configuration}
 ${rendererSource}`,
         enabledAgents: [
           "codex",
@@ -1798,21 +1335,22 @@ ${rendererSource}`,
           "deepseek-harness",
           "opencode",
           "grok",
-          "omp"
+          "omp",
+          "antigravity"
         ],
         timeoutMs: PRODUCTION_INSTALL_TIMEOUT_MS
       },
       dependencies
     );
-    startupTrace2("Renderer Session installed");
+    startupTrace("Renderer Session installed");
     return installed;
   };
-  startupTrace2("initialization started");
+  startupTrace("initialization started");
   try {
     session = await createSession();
     recordRecoverySuccess();
   } catch (error) {
-    startupTrace2("initial Renderer Session unavailable", error);
+    startupTrace("initial Renderer Session unavailable", error);
     session = void 0;
     recordRecoveryFailure();
   }
@@ -1847,7 +1385,7 @@ ${rendererSource}`,
   };
   let attachmentServer;
   try {
-    startupTrace2("starting attachment server");
+    startupTrace("starting attachment server");
     attachmentServer = await dependencies.startAttachmentServer({
       port: options.attachmentPort,
       nonce: options.attachmentNonce,
@@ -1856,8 +1394,8 @@ ${rendererSource}`,
         await current.activateDesktop();
       })
     });
-    startupTrace2("attachment server ready");
-    startupTrace2("publishing readiness");
+    startupTrace("attachment server ready");
+    startupTrace("publishing readiness");
     dependencies.ready({
       schemaVersion: 2,
       state: "compatible",