@karlorz/codexhost-cli-win32-x64 0.13.3-5 → 0.13.3-7

package/app/cpa-live-voice-hook.js

@@ -6,149 +6,6 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // src/renderer-cpa-live-voice-preference.ts
-  var CPA_LIVE_VOICE_STORAGE_KEY = "codexhost.cpa-live-voice.v1";
-  function cpaLiveVoicePreferenceAllowsInstall(globalObject) {
-    const storage = globalObject.localStorage;
-    if (!storage) return true;
-    try {
-      return storage.getItem(CPA_LIVE_VOICE_STORAGE_KEY) !== "0";
-    } catch {
-      return true;
-    }
-  }
-
-  // src/renderer-cpa-live-voice-hook.ts
-  var CPA_LIVE_VOICE_HOOK_GLOBAL = "__codexhostCpaLiveVoiceHookV1";
-  var AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION = "26.1007.30912";
-  var AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET = "app-initial-6350d04672d0.js";
-  var THREAD_REALTIME_EXISTING_CALL_GATE = "206132468";
-  var originalCheckGate = /* @__PURE__ */ new WeakMap();
-  var DISCOVERY_TIMEOUT_MS = 6e4;
-  function isRecord(value) {
-    return typeof value === "object" && value !== null;
-  }
-  function readCpaLiveVoiceHookConfig(globalObject) {
-    const value = globalObject[CPA_LIVE_VOICE_HOOK_GLOBAL];
-    if (!isRecord(value) || value.enabled !== true) return null;
-    if (typeof value.auditedDesktopVersion !== "string" || typeof value.auditedAppInitialAsset !== "string") {
-      return null;
-    }
-    return {
-      enabled: true,
-      auditedDesktopVersion: value.auditedDesktopVersion,
-      auditedAppInitialAsset: value.auditedAppInitialAsset,
-      ...typeof value.desktopVersion === "string" ? { desktopVersion: value.desktopVersion } : {}
-    };
-  }
-  function auditedAppInitialAssetPresent(resourceNames, asset) {
-    return resourceNames.some((name) => {
-      try {
-        const url2 = new URL(name, "app://-/");
-        return url2.protocol === "app:" && url2.hostname === "-" && url2.pathname === `/assets/${asset}`;
-      } catch {
-        return false;
-      }
-    });
-  }
-  function resourceNamesFromPerformance(source) {
-    const target = source ?? (typeof performance === "undefined" ? void 0 : performance);
-    if (!target || typeof target.getEntriesByType !== "function") return [];
-    return target.getEntriesByType("resource").map((entry) => entry.name).filter((name) => typeof name === "string");
-  }
-  function loadedAssetNames(root, performanceSource) {
-    const names = resourceNamesFromPerformance(performanceSource);
-    if (!root || !("querySelectorAll" in root)) return names;
-    for (const element of root.querySelectorAll("script[src], link[href]")) {
-      const value = element.getAttribute("src") ?? element.getAttribute("href");
-      if (value) names.push(value);
-    }
-    return names;
-  }
-  function statsigClients(globalObject) {
-    const registry2 = globalObject.__STATSIG__;
-    if (!isRecord(registry2)) return [];
-    const clients = new Set(
-      isRecord(registry2.instances) ? Object.values(registry2.instances) : []
-    );
-    if (registry2.firstInstance) clients.add(registry2.firstInstance);
-    return [...clients].filter(
-      (client) => isRecord(client) && typeof client.checkGate === "function"
-    );
-  }
-  function wrapCheckGate(client) {
-    if (originalCheckGate.has(client)) return false;
-    const original = client.checkGate;
-    originalCheckGate.set(client, original);
-    client.checkGate = function(name, ...rest) {
-      return name === THREAD_REALTIME_EXISTING_CALL_GATE ? false : original.call(this, name, ...rest);
-    };
-    return true;
-  }
-  function restoreCheckGate(client) {
-    const original = originalCheckGate.get(client);
-    if (!original) return;
-    client.checkGate = original;
-    originalCheckGate.delete(client);
-  }
-  function configAllowsInstall(config2, resourceNames) {
-    if (config2.desktopVersion !== void 0 && config2.desktopVersion !== config2.auditedDesktopVersion) {
-      return false;
-    }
-    if (config2.auditedDesktopVersion !== AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION) return false;
-    if (config2.auditedAppInitialAsset !== AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET) return false;
-    return auditedAppInitialAssetPresent(resourceNames, config2.auditedAppInitialAsset);
-  }
-  function installCpaLiveVoiceHook(options = {}) {
-    const globalObject = options.globalThis ?? globalThis;
-    const config2 = options.config === void 0 ? readCpaLiveVoiceHookConfig(globalObject) : options.config;
-    if (!config2?.enabled || !cpaLiveVoicePreferenceAllowsInstall(globalObject)) {
-      return { status: "disabled", dispose() {
-      } };
-    }
-    const root = options.document ?? globalObject.document;
-    const wrapped = [];
-    let disposed = false;
-    let auditedAssetFound = false;
-    const handle = {
-      status: "pending",
-      dispose() {
-        disposed = true;
-        for (const client of wrapped) restoreCheckGate(client);
-        wrapped.length = 0;
-      }
-    };
-    const attempt = () => {
-      if (!auditedAssetFound) {
-        const resourceNames = options.resourceNames ?? loadedAssetNames(root);
-        auditedAssetFound = configAllowsInstall(config2, resourceNames);
-        if (!auditedAssetFound) return false;
-      }
-      for (const client of statsigClients(globalObject)) {
-        if (wrapCheckGate(client)) wrapped.push(client);
-      }
-      if (wrapped.length === 0) return false;
-      handle.status = "active";
-      return true;
-    };
-    if (attempt()) return handle;
-    if (options.resourceNames && !configAllowsInstall(config2, options.resourceNames)) {
-      handle.status = "unsupported";
-      return handle;
-    }
-    const started = Date.now();
-    const tick = () => {
-      if (disposed || attempt()) return;
-      if (Date.now() - started > DISCOVERY_TIMEOUT_MS) {
-        handle.status = "unsupported";
-        return;
-      }
-      globalThis.setTimeout(tick, 250);
-    };
-    globalThis.setTimeout(tick, 250);
-    return handle;
-  }
-
   // ../../node_modules/zod/v4/classic/external.js
   var external_exports = {};
   __export(external_exports, {
@@ -14980,6 +14837,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
   });
   var CONSOLE_HOST_METHODS = Object.freeze([
+    "codexhost/voice/gateway-status",
     "codexhost/console/remote-connections",
     "codexhost/runtime/status",
     "codexhost/remote/ssh-setup",
@@ -14990,6 +14848,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "codexhost/harness/installation",
     "codexhost/harness/launch-settings/get",
     "codexhost/harness/launch-settings/set",
+    "codexhost/harness/grok-computer-use/get",
+    "codexhost/harness/grok-computer-use/set",
     "codexhost/harness/web-ui/open",
     "codexhost/harness/accounts/sources",
     "codexhost/harness/accounts/list",
@@ -15518,7 +15378,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var harnessInspectParamsSchema = external_exports.object({
     harnessId: harnessIdSchema,
     cwd: nonBlankTextSchema2.max(16384).optional(),
-    refresh: external_exports.boolean().optional()
+    refresh: external_exports.boolean().optional(),
+    /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+    purpose: external_exports.literal("availability").optional()
   }).strict();
   var harnessWebUiOpenParamsSchema = external_exports.object({
     harnessId: harnessIdSchema
@@ -15692,6 +15554,26 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     restartRequired: external_exports.boolean()
   }).strict();
 
+  // ../shared-contracts/dist/grok-computer-use.js
+  var grokComputerUseGetSchema = external_exports.object({}).strict();
+  var grokComputerUseSetSchema = external_exports.object({
+    enabled: external_exports.boolean().optional(),
+    browser: external_exports.boolean().optional()
+  }).strict().refine((value) => value.enabled !== void 0 || value.browser !== void 0, {
+    message: "Expected enabled or browser"
+  });
+  var grokComputerUseSettingsSchema = external_exports.object({
+    enabled: external_exports.boolean(),
+    available: external_exports.boolean(),
+    unavailableReason: external_exports.string().min(1).max(500).optional(),
+    browser: external_exports.boolean().optional(),
+    browserFilesPresent: external_exports.boolean().optional(),
+    browserAvailable: external_exports.boolean().optional(),
+    browserUnavailableReason: external_exports.string().min(1).max(500).optional(),
+    applyFailed: external_exports.boolean().optional(),
+    applyError: external_exports.string().min(1).max(500).optional()
+  }).strict();
+
   // ../shared-contracts/dist/harness-installation.js
   var harnessInstallationParamsSchema = external_exports.object({
     harnessId: harnessIdSchema,
@@ -16084,18 +15966,296 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     external_exports.strictObject({ error: external_exports.strictObject({ code: external_exports.number().int(), message: external_exports.string() }) })
   ]);
 
+  // ../shared-contracts/dist/voice-settings.js
+  var VOICE_GATEWAY_STATUS_METHOD = "codexhost/voice/gateway-status";
+  var voiceRoutesSchema = external_exports.strictObject({
+    chatExperience: external_exports.enum(["chatgpt", "codex"]),
+    chatConnection: external_exports.enum(["desktop", "gateway"]),
+    workConnection: external_exports.enum(["desktop", "gateway"])
+  });
+  var DEFAULT_VOICE_ROUTES = Object.freeze({
+    chatExperience: "chatgpt",
+    chatConnection: "desktop",
+    workConnection: "gateway"
+  });
+  var voiceSettingsSchema = voiceRoutesSchema.extend({ inject: external_exports.boolean() });
+  var voiceSettingsRequestSchema = external_exports.discriminatedUnion("operation", [
+    external_exports.strictObject({
+      operation: external_exports.literal("get"),
+      runtime: external_exports.strictObject({
+        id: external_exports.string().uuid(),
+        revision: external_exports.string().max(64),
+        activeCall: external_exports.boolean()
+      }).optional()
+    }),
+    external_exports.strictObject({ operation: external_exports.literal("migrate"), routes: voiceRoutesSchema }),
+    external_exports.strictObject({
+      operation: external_exports.literal("set"),
+      settings: voiceSettingsSchema,
+      revision: external_exports.string().max(64)
+    }),
+    external_exports.strictObject({ operation: external_exports.literal("restart"), confirm: external_exports.literal(true) })
+  ]);
+  var voiceSettingsStateSchema = external_exports.strictObject({
+    settings: voiceSettingsSchema,
+    initialized: external_exports.boolean(),
+    revision: external_exports.string(),
+    activeInject: external_exports.boolean().nullable(),
+    envOverride: external_exports.enum(["0", "1"]).nullable(),
+    activeEnvOverride: external_exports.enum(["0", "1"]).nullable(),
+    routesActive: external_exports.boolean().nullable(),
+    activeCall: external_exports.boolean().nullable(),
+    gatewayReady: external_exports.boolean().nullable(),
+    restartAvailable: external_exports.boolean(),
+    restart: external_exports.strictObject({
+      phase: external_exports.enum(["idle", "restarting", "succeeded", "failed"]),
+      error: external_exports.string().nullable()
+    })
+  });
+
   // ../shared-contracts/dist/index.js
   var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
+  // src/renderer-cpa-live-voice-preference.ts
+  var voiceStateOwner = globalThis;
+  var { sharedRoutes, gatewayReady } = voiceStateOwner.__codexhostVoicePreferenceStateV1 ??= {
+    sharedRoutes: /* @__PURE__ */ new WeakMap(),
+    gatewayReady: /* @__PURE__ */ new WeakMap()
+  };
+  var SHARED_VOICE_CACHE = "codexhost.voice-routes-cache.v1";
+  function cachedRoutes(owner) {
+    const memory = sharedRoutes.get(owner);
+    if (memory) return memory;
+    try {
+      const storage = owner.localStorage;
+      const parsed = voiceRoutesSchema.safeParse(
+        JSON.parse(storage?.getItem(SHARED_VOICE_CACHE) ?? "null")
+      ).data;
+      if (parsed) sharedRoutes.set(owner, parsed);
+      return parsed;
+    } catch {
+      return void 0;
+    }
+  }
+  var CPA_LIVE_VOICE_STORAGE_KEY = "codexhost.cpa-live-voice.v1";
+  var CHAT_LIVE_VOICE_STORAGE_KEY = "codexhost.chat-live-voice.v1";
+  function readFlag(owner, key, enabledWhenUnset) {
+    const storage = owner.localStorage;
+    if (!storage) return enabledWhenUnset;
+    try {
+      const value = storage.getItem(key);
+      return enabledWhenUnset ? value !== "0" : value === "1";
+    } catch {
+      return enabledWhenUnset;
+    }
+  }
+  function readCpaLiveVoicePreference(owner) {
+    const routes = cachedRoutes(owner);
+    return routes ? routes.workConnection === "gateway" : readFlag(owner, CPA_LIVE_VOICE_STORAGE_KEY, true);
+  }
+  function readChatLiveVoicePreference(owner) {
+    const routes = cachedRoutes(owner);
+    return routes ? routes.chatExperience === "codex" && routes.chatConnection === "gateway" : readFlag(owner, CHAT_LIVE_VOICE_STORAGE_KEY, false);
+  }
+  function cpaLiveVoicePreferenceAllowsInstall(globalObject) {
+    return readCpaLiveVoicePreference(globalObject);
+  }
+  function chatLiveVoicePreferenceAllowsOverride(globalObject) {
+    return readChatLiveVoicePreference(globalObject);
+  }
+
+  // src/renderer-cpa-live-voice-hook.ts
+  var CPA_LIVE_VOICE_HOOK_GLOBAL = "__codexhostCpaLiveVoiceHookV1";
+  var AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION = "26.1007.30912";
+  var AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET = "app-initial-6350d04672d0.js";
+  var THREAD_REALTIME_EXISTING_CALL_GATE = "206132468";
+  var originalCheckGate = /* @__PURE__ */ new WeakMap();
+  var DISCOVERY_TIMEOUT_MS = 6e4;
+  function isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  function readCpaLiveVoiceHookConfig(globalObject) {
+    const value = globalObject[CPA_LIVE_VOICE_HOOK_GLOBAL];
+    if (!isRecord(value) || value.enabled !== true) return null;
+    if (typeof value.auditedDesktopVersion !== "string" || typeof value.auditedAppInitialAsset !== "string") {
+      return null;
+    }
+    return {
+      enabled: true,
+      auditedDesktopVersion: value.auditedDesktopVersion,
+      auditedAppInitialAsset: value.auditedAppInitialAsset,
+      ...typeof value.desktopVersion === "string" ? { desktopVersion: value.desktopVersion } : {}
+    };
+  }
+  function auditedAppInitialAssetPresent(resourceNames, asset) {
+    return resourceNames.some((name) => {
+      try {
+        const url2 = new URL(name, "app://-/");
+        return url2.protocol === "app:" && url2.hostname === "-" && url2.pathname === `/assets/${asset}`;
+      } catch {
+        return false;
+      }
+    });
+  }
+  function resourceNamesFromPerformance(source) {
+    const target = source ?? (typeof performance === "undefined" ? void 0 : performance);
+    if (!target || typeof target.getEntriesByType !== "function") return [];
+    return target.getEntriesByType("resource").map((entry) => entry.name).filter((name) => typeof name === "string");
+  }
+  function loadedAssetNames(root, performanceSource) {
+    const names = resourceNamesFromPerformance(performanceSource);
+    if (!root || !("querySelectorAll" in root)) return names;
+    for (const element of root.querySelectorAll("script[src], link[href]")) {
+      const value = element.getAttribute("src") ?? element.getAttribute("href");
+      if (value) names.push(value);
+    }
+    return names;
+  }
+  function statsigClients(globalObject) {
+    const registry2 = globalObject.__STATSIG__;
+    if (!isRecord(registry2)) return [];
+    const clients = new Set(
+      isRecord(registry2.instances) ? Object.values(registry2.instances) : []
+    );
+    if (registry2.firstInstance) clients.add(registry2.firstInstance);
+    return [...clients].filter(
+      (client) => isRecord(client) && typeof client.checkGate === "function"
+    );
+  }
+  function wrapCheckGate(client) {
+    if (originalCheckGate.has(client)) return false;
+    const original = client.checkGate;
+    originalCheckGate.set(client, original);
+    client.checkGate = function(name, ...rest) {
+      return name === THREAD_REALTIME_EXISTING_CALL_GATE ? false : original.call(this, name, ...rest);
+    };
+    return true;
+  }
+  function restoreCheckGate(client) {
+    const original = originalCheckGate.get(client);
+    if (!original) return;
+    client.checkGate = original;
+    originalCheckGate.delete(client);
+  }
+  function configAllowsInstall(config2, resourceNames) {
+    if (config2.desktopVersion !== void 0 && config2.desktopVersion !== config2.auditedDesktopVersion) {
+      return false;
+    }
+    if (config2.auditedDesktopVersion !== AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION) return false;
+    if (config2.auditedAppInitialAsset !== AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET) return false;
+    return auditedAppInitialAssetPresent(resourceNames, config2.auditedAppInitialAsset);
+  }
+  function installCpaLiveVoiceHook(options = {}) {
+    const globalObject = options.globalThis ?? globalThis;
+    const config2 = options.config === void 0 ? readCpaLiveVoiceHookConfig(globalObject) : options.config;
+    if (!config2?.enabled || !cpaLiveVoicePreferenceAllowsInstall(globalObject)) {
+      return { status: "disabled", dispose() {
+      } };
+    }
+    const root = options.document ?? globalObject.document;
+    const wrapped = [];
+    let disposed = false;
+    let auditedAssetFound = false;
+    const handle = {
+      status: "pending",
+      dispose() {
+        disposed = true;
+        for (const client of wrapped) restoreCheckGate(client);
+        wrapped.length = 0;
+      }
+    };
+    const attempt = () => {
+      if (!auditedAssetFound) {
+        const resourceNames = options.resourceNames ?? loadedAssetNames(root);
+        auditedAssetFound = configAllowsInstall(config2, resourceNames);
+        if (!auditedAssetFound) return false;
+      }
+      for (const client of statsigClients(globalObject)) {
+        if (wrapCheckGate(client)) wrapped.push(client);
+      }
+      if (wrapped.length === 0) return false;
+      handle.status = "active";
+      return true;
+    };
+    if (attempt()) return handle;
+    if (options.resourceNames && !configAllowsInstall(config2, options.resourceNames)) {
+      handle.status = "unsupported";
+      return handle;
+    }
+    const started = Date.now();
+    const tick = () => {
+      if (disposed || attempt()) return;
+      if (Date.now() - started > DISCOVERY_TIMEOUT_MS) {
+        handle.status = "unsupported";
+        return;
+      }
+      globalThis.setTimeout(tick, 250);
+    };
+    globalThis.setTimeout(tick, 250);
+    return handle;
+  }
+
+  // src/renderer-voice-assets.ts
+  function supportsVoiceVersion(profiles, version2) {
+    return version2 === void 0 || profiles.some((profile) => profile.version === version2);
+  }
+  function selectVoiceAssets(profiles, names, version2) {
+    const present = profiles.filter(
+      (profile2) => [profile2.initial, profile2.shared].some((asset) => auditedAppInitialAssetPresent(names, asset))
+    );
+    const profile = present.length === 1 ? present[0] : void 0;
+    return profile && (version2 === void 0 || profile.version === version2) && [profile.initial, profile.shared].every((asset) => auditedAppInitialAssetPresent(names, asset)) ? profile : void 0;
+  }
+
+  // src/renderer-chat-voice-debug.ts
+  var CHAT_VOICE_DEBUG_GLOBAL = "__codexhostChatVoiceDebug";
+  var CHAT_VOICE_DEBUG_STORAGE_KEY = "codexhost.chat-voice-debug.v1";
+  function chatVoiceDebug(event, detail = {}) {
+    const entry = { t: Date.now(), event, ...detail };
+    const owner = globalThis;
+    const log = Array.isArray(owner[CHAT_VOICE_DEBUG_GLOBAL]) ? owner[CHAT_VOICE_DEBUG_GLOBAL] : [];
+    log.push(entry);
+    while (log.length > 40) log.shift();
+    owner[CHAT_VOICE_DEBUG_GLOBAL] = log;
+    try {
+      owner.localStorage?.setItem(CHAT_VOICE_DEBUG_STORAGE_KEY, JSON.stringify(log));
+    } catch {
+    }
+    owner.console?.info?.("[codexhost-chat-voice]", event, detail);
+  }
+
+  // src/renderer-new-thread-preference.ts
+  var RENDERER_NEW_THREAD_PREFERENCE_KEY = "codexhost.new-thread-preference.v1";
+
   // src/renderer-client-owned-voice.ts
-  var CLIENT_OWNED_VOICE_VERSION = "26.1013.40934";
-  var CLIENT_OWNED_VOICE_INITIAL_ASSET = "app-initial-90eb42395b7d.js";
-  var CLIENT_OWNED_VOICE_SHARED_ASSET = "app-shared-52443cbe9ac4.js";
+  var CLIENT_OWNED_VOICE_VERSION = "26.1016.62342";
+  var CLIENT_OWNED_VOICE_INITIAL_ASSET = "app-initial-dddef47d6ef6.js";
+  var CLIENT_OWNED_VOICE_SHARED_ASSET = "app-shared-fc3316d48427.js";
+  var CLIENT_OWNED_VOICE_SERVICES = "ist";
+  var CLIENT_OWNED_VOICE_OVERLAY_ASSET = "avatar-overlay-native-page-ef8332c6a2fb.js";
+  var CLIENT_OWNED_VOICE_ASSETS = [
+    {
+      version: CLIENT_OWNED_VOICE_VERSION,
+      initial: CLIENT_OWNED_VOICE_INITIAL_ASSET,
+      shared: CLIENT_OWNED_VOICE_SHARED_ASSET,
+      overlay: CLIENT_OWNED_VOICE_OVERLAY_ASSET
+    },
+    {
+      version: "26.1016.61520",
+      initial: "app-initial-c95ddb62696e.js",
+      shared: "app-shared-2eda13eb7044.js",
+      overlay: "avatar-overlay-native-page-fcc17283519a.js"
+    }
+  ];
+  var SHARED_INIT = "Oit";
+  var SHARED_FETCH = "Eit";
+  var SHARED_BRIDGE = "AFt";
+  var SHARED_RESPONSE_ERROR = "Mit";
   var HOOK_GLOBAL = "__codexhostClientOwnedVoiceV1";
   function object2(value) {
     return value !== null && typeof value === "object";
   }
-  function requestHost(bridge, params) {
+  function requestVoiceHost(bridge, params, method = REALTIME_CALL_METHOD) {
     const id = `codexhost-voice:${crypto.randomUUID()}`;
     return new Promise((resolve, reject) => {
       let unsubscribe = () => {
@@ -16118,7 +16278,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       try {
         bridge.dispatchMessage("mcp-request", {
           hostId: "local",
-          request: { id, method: REALTIME_CALL_METHOD, params }
+          request: { id, method, params }
         });
       } catch {
         done();
@@ -16126,11 +16286,122 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     });
   }
-  function wrapClientOwnedVoiceFetch(client, bridge, enabled, responseError) {
+  var HOME_COMPOSER_MODE_STORAGE_KEY = "home-composer-mode-v1";
+  function backendModelName(headers) {
+    const raw = new Headers(headers).get("x-codex-turn-metadata");
+    if (!raw) return "";
+    try {
+      const parsed = JSON.parse(raw);
+      return typeof parsed.backend_model_name === "string" ? parsed.backend_model_name : "";
+    } catch {
+      return "";
+    }
+  }
+  function isWorkBackendModel(name) {
+    const model2 = name.toLowerCase();
+    if (!model2) return false;
+    if (model2.startsWith("codexhost/")) return true;
+    return model2.includes("codex") && !model2.includes("gpt-live");
+  }
+  function visibleWorkComposer(owner) {
+    const document = owner.document;
+    if (!document?.querySelectorAll) return false;
+    const work = [...document.querySelectorAll("[data-codex-composer-root]")].some((element) => {
+      const box = element.getBoundingClientRect?.() ?? { width: 0 };
+      return box.width > 0 && !element.closest?.("[hidden], [inert]");
+    });
+    return work && document.querySelectorAll("[data-chatgpt-composer]").length === 0;
+  }
+  function selectedWorkTab(owner) {
+    const document = owner.document;
+    if (!document?.querySelectorAll) return false;
+    const controls = document.querySelectorAll("button, [role='tab'], a");
+    let workSelected = false;
+    let chatSelected = false;
+    for (const element of controls) {
+      const name = (element.textContent ?? "").replace(/\s+/gu, " ").trim();
+      if (name !== "Chat" && name !== "Work") continue;
+      const selected = element.getAttribute("aria-selected") === "true" || element.getAttribute("aria-pressed") === "true" || element.getAttribute("data-state") === "active" || element.getAttribute("data-state") === "on";
+      if (!selected) continue;
+      if (name === "Work") workSelected = true;
+      if (name === "Chat") chatSelected = true;
+    }
+    return workSelected && !chatSelected;
+  }
+  function isWorkComposerSurface(owner = globalThis) {
+    const storage = owner.localStorage;
+    try {
+      const raw = storage?.getItem(HOME_COMPOSER_MODE_STORAGE_KEY);
+      if (raw != null && raw !== "") {
+        let value = raw;
+        if (raw.startsWith("{") || raw.startsWith('"') || raw.startsWith("[")) {
+          try {
+            value = JSON.parse(raw);
+          } catch {
+            value = raw;
+          }
+        }
+        if (value === "work") return true;
+        if (value === "chat") return false;
+      }
+    } catch {
+    }
+    return selectedWorkTab(owner) || visibleWorkComposer(owner);
+  }
+  function selectedComposerModel(owner) {
+    const routing = owner.__codexhostHostRoutingV1;
+    try {
+      const model2 = routing?.forComposer()?.policy.selectedModel();
+      return typeof model2 === "string" ? model2 : "";
+    } catch {
+      return "";
+    }
+  }
+  var lastVoiceProductExperience;
+  function rememberVoiceProductExperience(request) {
+    const experience = object2(request) ? request.productExperience : void 0;
+    lastVoiceProductExperience = experience === "chat" || experience === "work" ? experience : void 0;
+  }
+  function lastVoiceLaunchProductExperience() {
+    return lastVoiceProductExperience;
+  }
+  function isExternalHarnessComposer(owner = globalThis) {
+    if (lastVoiceProductExperience === "chat") return false;
+    if (selectedComposerModel(owner).startsWith("codexhost/")) return true;
+    if (lastVoiceProductExperience !== "work") return false;
+    const storage = owner.localStorage;
+    if (!storage) return false;
+    try {
+      const parsed = JSON.parse(storage.getItem(RENDERER_NEW_THREAD_PREFERENCE_KEY) ?? "");
+      return typeof parsed.lastAgent === "string" && parsed.lastAgent !== "" && parsed.lastAgent !== "codex";
+    } catch {
+      return false;
+    }
+  }
+  function wrapClientOwnedVoiceFetch(client, bridge, workOverride, responseError, chatOverride = () => false, workSurface = () => isWorkComposerSurface(), externalHarness = () => isExternalHarnessComposer()) {
     const original = client.fetch;
     const wrapped = async function(url2, options) {
-      if (typeof url2 !== "string" || url2.split("?")[0] !== "/wham/realtime/calls" || options?.method !== "POST" || !enabled())
+      if (typeof url2 !== "string" || url2.split("?")[0] !== "/wham/realtime/calls" || options?.method !== "POST")
         return original.call(this, url2, options);
+      const experience = lastVoiceLaunchProductExperience();
+      const chat = experience === "chat";
+      const model2 = backendModelName(options.headers);
+      const work = !chat && (experience === "work" || isWorkBackendModel(model2) || workSurface());
+      const external = !chat && (model2.startsWith("codexhost/") || externalHarness());
+      const gateway = external || (work ? workOverride() : chatOverride());
+      chatVoiceDebug("wham-create", {
+        work,
+        external,
+        route: gateway ? "gateway" : "desktop",
+        productExperience: experience ?? "unset"
+      });
+      if (!gateway) {
+        if (!external && !work)
+          chatVoiceDebug("chat-native-passthrough", {
+            hasThreadId: new Headers(options.headers).has("Thread-Id")
+          });
+        return original.call(this, url2, options);
+      }
       if (typeof options.body !== "string") throw new Error("Unsupported native voice call request");
       options.signal?.throwIfAborted();
       const requestId2 = crypto.randomUUID();
@@ -16138,12 +16409,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const cancel = () => {
         if (cancelled) return;
         cancelled = true;
-        void requestHost(bridge, { operation: "cancel", requestId: requestId2 }).catch(() => void 0);
+        void requestVoiceHost(bridge, { operation: "cancel", requestId: requestId2 }).catch(() => void 0);
       };
       options.signal?.addEventListener("abort", cancel, { once: true });
       try {
         const result = realtimeCallResponseSchema.parse(
-          await requestHost(bridge, {
+          await requestVoiceHost(bridge, {
             operation: "create",
             requestId: requestId2,
             body: options.body,
@@ -16155,7 +16426,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         if (options.signal?.aborted) {
           const callId = realtimeCallIdFromLocation(result.headers.location ?? "");
           if (result.status >= 200 && result.status < 300 && isRealtimeCallId(callId))
-            await requestHost(bridge, { operation: "hangup", callId });
+            await requestVoiceHost(bridge, { operation: "hangup", callId });
           options.signal.throwIfAborted();
         }
         const response = new Response(result.status === 204 ? null : result.body, {
@@ -16181,10 +16452,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const existing = target[HOOK_GLOBAL];
     if (existing) return existing;
     const config2 = readCpaLiveVoiceHookConfig(target);
-    if (!config2 || !cpaLiveVoicePreferenceAllowsInstall(target))
-      return { status: "disabled", dispose() {
-      } };
-    if (config2.desktopVersion !== void 0 && config2.desktopVersion !== CLIENT_OWNED_VOICE_VERSION)
+    if (!config2) return { status: "disabled", dispose() {
+    } };
+    if (!supportsVoiceVersion(CLIENT_OWNED_VOICE_ASSETS, config2.desktopVersion))
       return { status: "unsupported", dispose() {
       } };
     const importModule = options.importModule ?? ((url2) => import(url2));
@@ -16205,23 +16475,29 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const attempt = async () => {
       if (disposed) return;
       const names = loadedAssetNames(target.document, target.performance);
-      if (auditedAppInitialAssetPresent(names, CLIENT_OWNED_VOICE_INITIAL_ASSET) && auditedAppInitialAssetPresent(names, CLIENT_OWNED_VOICE_SHARED_ASSET)) {
+      const assets = selectVoiceAssets(CLIENT_OWNED_VOICE_ASSETS, names, config2.desktopVersion);
+      if (assets) {
         try {
-          const module = await importModule(`app://-/assets/${CLIENT_OWNED_VOICE_SHARED_ASSET}`);
+          const module = await importModule(`app://-/assets/${assets.shared}`);
           if (disposed) return;
-          const fetchClass = module.urt;
-          const bridgeClass = module.mPt;
+          if (typeof module[SHARED_INIT] !== "function") throw new Error();
+          module[SHARED_INIT]();
+          const fetchClass = module[SHARED_FETCH];
+          const bridgeClass = module[SHARED_BRIDGE];
           if (!object2(fetchClass) && typeof fetchClass !== "function") throw new Error();
           if (!object2(bridgeClass) && typeof bridgeClass !== "function") throw new Error();
           const client = Reflect.get(fetchClass, "getInstance").call(fetchClass);
           const bridge = Reflect.get(bridgeClass, "getInstance").call(bridgeClass);
-          if (typeof client?.fetch !== "function" || typeof bridge?.dispatchMessage !== "function" || typeof bridge?.subscribe !== "function" || typeof module.grt !== "function")
+          if (typeof client?.fetch !== "function" || typeof bridge?.dispatchMessage !== "function" || typeof bridge?.subscribe !== "function" || typeof module[SHARED_RESPONSE_ERROR] !== "function")
             throw new Error();
           restore = wrapClientOwnedVoiceFetch(
             client,
             bridge,
             () => cpaLiveVoicePreferenceAllowsInstall(target),
-            module.grt
+            module[SHARED_RESPONSE_ERROR],
+            () => chatLiveVoicePreferenceAllowsOverride(target),
+            () => isWorkComposerSurface(target),
+            () => isExternalHarnessComposer(target)
           );
           handle.status = "active";
         } catch {
@@ -16306,8 +16582,432 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
   }
 
+  // ../desktop-control/dist/renderer-react-ownership.js
+  function committedReactAncestors(value) {
+    const MAX_VISITED_FIBERS = 2e5;
+    const fiber = (value2) => typeof value2 === "object" && value2 !== null ? value2 : null;
+    const exhausted = () => {
+      const target = globalThis;
+      if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function")
+        target.dispatchEvent(new CustomEvent("codexhost:react-fiber-walk-limit", {
+          detail: { limit: MAX_VISITED_FIBERS }
+        }));
+      return [];
+    };
+    const first = fiber(value);
+    if (!first)
+      return [];
+    const previous = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let node = first; node; node = fiber(node.return)) {
+      if (seen.has(node))
+        return [];
+      if (seen.size >= MAX_VISITED_FIBERS)
+        return exhausted();
+      seen.add(node);
+      previous.push(node);
+    }
+    const rootState = fiber(previous.at(-1)?.stateNode);
+    if (!rootState || !("current" in rootState))
+      return previous;
+    const current = fiber(rootState.current);
+    if (!current)
+      return [];
+    const alternate = fiber(first.alternate);
+    const path = [current];
+    seen.clear();
+    seen.add(current);
+    for (let index = previous.length - 2; index >= 0; index -= 1) {
+      const expected = previous[index];
+      const expectedAlternate = fiber(expected?.alternate);
+      let child = fiber(path.at(-1)?.child);
+      let matched = false;
+      while (child && !seen.has(child) && seen.size < MAX_VISITED_FIBERS) {
+        seen.add(child);
+        if (child === expected || child === expectedAlternate) {
+          matched = true;
+          break;
+        }
+        child = fiber(child.sibling);
+      }
+      if (!matched || !child)
+        break;
+      path.push(child);
+    }
+    if (path.length === previous.length && (path.at(-1) === first || path.at(-1) === alternate)) {
+      return path.reverse();
+    }
+    const stack = [{ node: current, parent: null }];
+    seen.clear();
+    while (stack.length > 0 && seen.size < MAX_VISITED_FIBERS) {
+      const entry = stack.pop();
+      if (!entry)
+        break;
+      if (seen.has(entry.node))
+        return [];
+      seen.add(entry.node);
+      if (entry.node === first || entry.node === alternate) {
+        const ancestors = [];
+        for (let cursor = entry; cursor; cursor = cursor.parent)
+          ancestors.push(cursor.node);
+        return ancestors;
+      }
+      const sibling = entry.parent && fiber(entry.node.sibling);
+      if (sibling)
+        stack.push({ node: sibling, parent: entry.parent });
+      const child = fiber(entry.node.child);
+      if (child)
+        stack.push({ node: child, parent: entry });
+    }
+    return stack.length > 0 ? exhausted() : [];
+  }
+
+  // src/renderer-voice-capability.ts
+  var INFERENCE_GATE = "3683713372";
+  var record2 = (value) => value !== null && typeof value === "object";
+  var capable = (value) => record2(value) && typeof value.isLoading === "boolean" && typeof value.isError === "boolean" && typeof value.isCapable === "boolean";
+  var equal = (a, b) => a.isLoading === b.isLoading && a.isError === b.isError && a.isCapable === b.isCapable;
+  function replayVoiceCapability(store, atom, gate) {
+    const evaluate = (override) => {
+      const visiting = /* @__PURE__ */ new Set();
+      let remaining = 512;
+      let hits = 0;
+      const read = (dependency) => {
+        if (--remaining < 0) throw new Error("Voice capability dependency limit");
+        const value = store.get(dependency);
+        if (dependency === gate) {
+          hits += 1;
+          if (typeof value !== "boolean") throw new Error("Voice inference gate unavailable");
+          return override ? false : value;
+        }
+        if (dependency.write || visiting.has(dependency)) return value;
+        if (typeof dependency.read !== "function") throw new Error("Voice dependency unavailable");
+        visiting.add(dependency);
+        try {
+          return dependency.read(read);
+        } finally {
+          visiting.delete(dependency);
+        }
+      };
+      return { value: read(atom), hits };
+    };
+    try {
+      const native = store.get(atom);
+      if (!capable(native) || native.isLoading || native.isError) return null;
+      const before = evaluate(false);
+      if (!capable(before.value) || !equal(native, before.value)) return null;
+      const after = evaluate(true);
+      return after.hits > 0 && capable(after.value) && !after.value.isLoading && !after.value.isError ? after.value : null;
+    } catch {
+      return null;
+    }
+  }
+  function hooks(fiber) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    let hook = fiber.memoizedState;
+    while (record2(hook) && result.length < 4096 && !seen.has(hook)) {
+      seen.add(hook);
+      result.push(hook);
+      hook = hook.next;
+    }
+    return hook == null ? result : [];
+  }
+  function bindVoiceCapabilitySubscriptions(currentFibers, family, gates, allowed, realtimeOnly = false) {
+    const fibers = currentFibers();
+    const restores = [];
+    const bindings = [];
+    try {
+      for (const fiber of fibers) {
+        const list = hooks(fiber);
+        for (const memo of list) {
+          const [signal, deps] = Array.isArray(memo.memoizedState) ? memo.memoizedState : [];
+          if (!record2(signal) || !Array.isArray(deps) || deps.length !== 5 || deps[3] !== family || !(deps[1] instanceof Map) || deps[2] !== void 0)
+            continue;
+          const chain = deps[1];
+          const node = chain.get(family.scope.id);
+          const members = node?.familyBindings?.get(family);
+          if (!node || !(members instanceof Map) || node.store !== signal.store) continue;
+          const matches = [...members].filter(([, member]) => member.cacheKey === deps[0]);
+          if (matches.length !== 1 || typeof matches[0]?.[0] !== "string") continue;
+          const parameter = JSON.parse(matches[0][0]);
+          if (!record2(parameter) || Object.keys(parameter).some((key) => key !== "name" && key !== "hostId") || parameter.name !== "voice.realtime" && parameter.name !== "voice.thread" || realtimeOnly && parameter.name !== "voice.realtime" || parameter.hostId !== void 0 && parameter.hostId !== "local" || parameter.name === "voice.thread" && parameter.hostId !== "local")
+            continue;
+          const subscriptions = list.filter((hook2) => {
+            const state = hook2.memoizedState;
+            return Array.isArray(state) && Array.isArray(state[1]) && state[1].length === 2 && state[1][0] === signal && state[1][1] === void 0 && typeof state[0]?.getSnapshot === "function";
+          });
+          if (subscriptions.length !== 1) throw new Error("Ambiguous voice subscription");
+          const hook = subscriptions[0];
+          const subscriber = hook.memoizedState[0];
+          const instance = hook.next?.queue;
+          const effect = hook.next?.next?.memoizedState;
+          const store = signal.store;
+          const gate = gates.resolve(node, chain, INFERENCE_GATE)?.atom;
+          if (!gate || !instance || !record2(effect) || !Array.isArray(effect.deps) || effect.deps[0] !== subscriber.subscribe || typeof effect.create !== "function" || typeof instance.getSnapshot !== "function" || !capable(store.get(signal.atom)) || !capable(subscriber.getSnapshot()) || !capable(instance.getSnapshot()) || !equal(
+            store.get(signal.atom),
+            subscriber.getSnapshot()
+          ) || !equal(subscriber.getSnapshot(), instance.getSnapshot()) || subscriber.createRender?.() != null)
+            throw new Error("Unsupported voice subscription");
+          for (const [object3, key] of [
+            [store, "sub"],
+            [subscriber, "getSnapshot"],
+            [instance, "getSnapshot"]
+          ])
+            if (Object.getOwnPropertyDescriptor(object3, key)?.writable !== true)
+              throw new Error("Voice subscription is not writable");
+          let notify;
+          const sub = store.sub;
+          try {
+            store.sub = (atom, listener) => {
+              if (atom !== signal.atom || notify) throw new Error("Unexpected voice subscription");
+              notify = listener;
+              return () => {
+              };
+            };
+            effect.create();
+          } finally {
+            store.sub = sub;
+          }
+          if (!notify) throw new Error("Voice listener unavailable");
+          const original = subscriber.getSnapshot;
+          const originalInstance = instance.getSnapshot;
+          let previous;
+          const snapshot = () => {
+            const native = original.call(subscriber);
+            if (!allowed()) return native;
+            const projected = replayVoiceCapability(store, signal.atom, gate);
+            if (!projected || !projected.isCapable) return native;
+            if (!previous || !equal(previous, projected)) previous = projected;
+            return previous;
+          };
+          subscriber.getSnapshot = snapshot;
+          instance.getSnapshot = snapshot;
+          const onChange = notify;
+          restores.push(() => {
+            if (subscriber.getSnapshot === snapshot) subscriber.getSnapshot = original;
+            if (instance.getSnapshot === snapshot) instance.getSnapshot = originalInstance;
+            onChange();
+          });
+          bindings.push({ subscriber, signal, instance });
+          onChange();
+        }
+      }
+      if (!restores.length) throw new Error("Owned voice capability unavailable");
+      if (realtimeOnly && restores.length !== 1) throw new Error("Ambiguous voice starter");
+    } catch (error51) {
+      for (const restore of restores.reverse()) restore();
+      throw error51;
+    }
+    return {
+      dispose() {
+        for (const restore of restores.splice(0).reverse()) restore();
+      },
+      current() {
+        const current = [...currentFibers()].flatMap(hooks);
+        return bindings.every(
+          ({ subscriber, signal, instance }) => current.some(
+            (hook) => Array.isArray(hook.memoizedState) && hook.memoizedState[0] === subscriber && hook.memoizedState[1]?.[0] === signal && hook.next?.queue === instance && (!realtimeOnly || capable(hook.next?.memoizedState) && hook.next.memoizedState.isCapable)
+          )
+        );
+      }
+    };
+  }
+
+  // src/renderer-voice-start-capability.ts
+  var GLOBAL = "__codexhostVoiceStartCapabilityV1";
+  var record3 = (v) => v !== null && typeof v === "object";
+  function gatewayVoiceStartRequest(request, workGateway, chatGateway = false) {
+    if (!record3(request) || request.productExperience !== "work" && request.productExperience !== "chat")
+      return false;
+    if (request.source === "composer_button_existing_thread") {
+      if (!record3(request.locator) || request.locator.hostId !== "local") return false;
+    } else if (request.source !== "composer_button_new_thread" || (request.hostId ?? "local") !== "local")
+      return false;
+    if (request.productExperience === "chat") return chatGateway;
+    const mode = request.activeCollaborationMode;
+    const settings = record3(mode) ? mode.settings : void 0;
+    const model2 = record3(settings) ? settings.model : void 0;
+    return workGateway || typeof model2 === "string" && model2.startsWith("codexhost/");
+  }
+  function wrapGatewayVoiceStarter(start, options) {
+    let active;
+    return {
+      async start(...args) {
+        if (!options.qualifies(args[0])) return start(...args);
+        if (active) throw new Error("Voice gateway start is already pending");
+        const attempt = {};
+        active = attempt;
+        const allowed = () => active === attempt && options.qualifies(args[0]);
+        try {
+          if (!await options.ready()) throw new Error("Voice gateway is not ready");
+          if (!allowed()) throw new Error("Voice gateway start was cancelled");
+          attempt.binding = await options.prepare(allowed);
+          await options.committed(attempt.binding);
+          if (!allowed()) throw new Error("Voice gateway start was cancelled");
+          if (!attempt.binding.current()) throw new Error("Voice starter subscription changed");
+          rememberVoiceProductExperience(args[0]);
+          return await start(...args);
+        } finally {
+          attempt.binding?.dispose();
+          if (active === attempt) active = void 0;
+        }
+      },
+      cancel() {
+        active?.binding?.dispose();
+        active = void 0;
+      }
+    };
+  }
+  function overlayVoiceStarterFibers(document, page) {
+    const fibers = /* @__PURE__ */ new Set();
+    for (const element of document.querySelectorAll("[data-avatar-overlay-native-surface-id]")) {
+      const key = Object.getOwnPropertyNames(element).find((key2) => key2.startsWith("__reactFiber$"));
+      const ancestors = committedReactAncestors(
+        key && Object.getOwnPropertyDescriptor(element, key)?.value
+      );
+      const boundary = ancestors.findIndex((fiber) => record3(fiber) && fiber.type === page);
+      if (boundary < 0) continue;
+      for (const fiber of ancestors.slice(0, boundary)) if (record3(fiber)) fibers.add(fiber);
+    }
+    return fibers;
+  }
+  function installVoiceStartCapabilityHook(options = {}) {
+    const target = options.target ?? globalThis;
+    if (target[GLOBAL]) return target[GLOBAL];
+    const config2 = readCpaLiveVoiceHookConfig(target);
+    if (!config2 || !isAvatarOverlayHref(target.location?.href ?? ""))
+      return { status: "disabled", dispose() {
+      } };
+    if (!supportsVoiceVersion(CLIENT_OWNED_VOICE_ASSETS, config2.desktopVersion))
+      return { status: "unsupported", dispose() {
+      } };
+    const importModule = options.importModule ?? ((url2) => import(url2));
+    let disposed = false;
+    let timer;
+    let restore;
+    const wrappers = /* @__PURE__ */ new Set();
+    const started = Date.now();
+    const handle = {
+      status: "pending",
+      dispose() {
+        disposed = true;
+        target.clearTimeout(timer);
+        for (const wrapper of wrappers) wrapper.cancel();
+        restore?.();
+        if (target[GLOBAL] === handle) Reflect.deleteProperty(target, GLOBAL);
+      }
+    };
+    target[GLOBAL] = handle;
+    const attempt = async () => {
+      if (disposed) return;
+      try {
+        const names = loadedAssetNames(target.document, target.performance);
+        const assets = selectVoiceAssets(CLIENT_OWNED_VOICE_ASSETS, names, config2.desktopVersion);
+        if (assets) {
+          const shared = await importModule(`app://-/assets/${assets.shared}`);
+          if (typeof shared.Oit !== "function") throw new Error("Voice bridge unavailable");
+          shared.Oit();
+          const services = shared[CLIENT_OWNED_VOICE_SERVICES];
+          if (record3(services) && (record3(services.realtimeVoiceRuntime) || typeof services.realtimeVoiceRuntime === "function")) {
+            const original = services.realtimeVoiceRuntime;
+            const register = Reflect.get(original, "registerRealtimeStarter");
+            if (typeof register !== "function") throw new Error("Voice starter unavailable");
+            const wrapped = new Proxy(original, {
+              get(service, key, receiver) {
+                if (key === "registerRealtimeStarter")
+                  return (start, cancel, ...rest) => {
+                    if (typeof start !== "function" || typeof cancel !== "function")
+                      throw new Error("Voice starter callback unavailable");
+                    const wrapper = wrapGatewayVoiceStarter(start, {
+                      qualifies: (request) => !disposed && !!readCpaLiveVoiceHookConfig(target) && gatewayVoiceStartRequest(
+                        request,
+                        cpaLiveVoicePreferenceAllowsInstall(target),
+                        chatLiveVoicePreferenceAllowsOverride(target)
+                      ),
+                      ready: async () => {
+                        const hook = target.__codexhostClientOwnedVoiceV1;
+                        if (!record3(hook) || hook.status !== "active") return false;
+                        const bridgeClass = shared.AFt;
+                        const result = await requestVoiceHost(
+                          bridgeClass.getInstance(),
+                          {},
+                          VOICE_GATEWAY_STATUS_METHOD
+                        );
+                        return result === true;
+                      },
+                      prepare: async (allowed) => {
+                        const names2 = loadedAssetNames(target.document, target.performance);
+                        if (!auditedAppInitialAssetPresent(names2, assets.overlay))
+                          throw new Error("Unaudited voice starter");
+                        const [initial, overlay] = await Promise.all([
+                          importModule(`app://-/assets/${assets.initial}`),
+                          importModule(`app://-/assets/${assets.overlay}`)
+                        ]);
+                        if (typeof initial.njr !== "function" || typeof overlay.AvatarOverlayNativePage !== "function" || !target.document)
+                          throw new Error("Voice starter owner unavailable");
+                        const document = target.document;
+                        initial.njr();
+                        return bindVoiceCapabilitySubscriptions(
+                          () => overlayVoiceStarterFibers(document, overlay.AvatarOverlayNativePage),
+                          initial.tjr,
+                          initial.uBr,
+                          allowed,
+                          true
+                        );
+                      },
+                      // Wait for React's committed snapshot, including when the
+                      // persistent overlay is hidden. A stale closure fails closed.
+                      committed: async (binding) => {
+                        for (let i = 0; i < 40 && !disposed && !binding.current(); i += 1)
+                          await new Promise((resolve) => target.setTimeout(resolve, 50));
+                      }
+                    });
+                    wrappers.add(wrapper);
+                    return Reflect.apply(register, original, [
+                      wrapper.start,
+                      (...args) => {
+                        wrapper.cancel();
+                        return cancel(...args);
+                      },
+                      ...rest
+                    ]);
+                  };
+                if (key === "unregisterRealtimeStarter")
+                  return (...args) => {
+                    for (const wrapper of wrappers) wrapper.cancel();
+                    wrappers.clear();
+                    return Reflect.apply(Reflect.get(service, key), service, args);
+                  };
+                return Reflect.get(service, key, receiver);
+              }
+            });
+            if (disposed) return;
+            if (!Reflect.set(services, "realtimeVoiceRuntime", wrapped))
+              throw new Error("Voice service is not writable");
+            restore = () => {
+              if (services.realtimeVoiceRuntime === wrapped) services.realtimeVoiceRuntime = original;
+            };
+            handle.status = "active";
+            return;
+          }
+        }
+        if (Date.now() - started >= 6e4) {
+          handle.status = "unsupported";
+          return;
+        }
+        timer = target.setTimeout(() => void attempt(), 25);
+      } catch {
+        handle.status = "unsupported";
+      }
+    };
+    void attempt();
+    return handle;
+  }
+
   // src/cpa-live-voice-entry.ts
   installCpaLiveVoiceHook();
   installClientOwnedVoiceHook();
+  installVoiceStartCapabilityHook();
   installOverlayThreadIsolation();
 })();