@karlorz/codexhost-cli-win32-arm64 0.13.3-6 → 0.13.3-7

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

@@ -14848,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",
@@ -15376,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
@@ -15550,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,
@@ -15943,6 +15967,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   ]);
 
   // ../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"]),
@@ -15992,7 +16017,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
   // src/renderer-cpa-live-voice-preference.ts
-  var sharedRoutes = /* @__PURE__ */ new WeakMap();
+  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);
@@ -16166,6 +16195,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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";
@@ -16187,14 +16228,34 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   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 = () => {
@@ -16217,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();
@@ -16242,24 +16303,50 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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;
-    if (!storage) return false;
     try {
-      const raw = storage.getItem(HOME_COMPOSER_MODE_STORAGE_KEY);
-      if (raw == null || raw === "") return false;
-      let value = raw;
-      if (raw.startsWith("{") || raw.startsWith('"') || raw.startsWith("[")) {
-        try {
-          value = JSON.parse(raw);
-        } catch {
-          value = raw;
+      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;
       }
-      return value === "work";
     } catch {
-      return false;
     }
+    return selectedWorkTab(owner) || visibleWorkComposer(owner);
   }
   function selectedComposerModel(owner) {
     const routing = owner.__codexhostHostRoutingV1;
@@ -16271,6 +16358,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
   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;
   }
@@ -16292,16 +16383,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const wrapped = async function(url2, options) {
       if (typeof url2 !== "string" || url2.split("?")[0] !== "/wham/realtime/calls" || options?.method !== "POST")
         return original.call(this, url2, options);
-      const chat = lastVoiceLaunchProductExperience() === "chat";
+      const experience = lastVoiceLaunchProductExperience();
+      const chat = experience === "chat";
       const model2 = backendModelName(options.headers);
-      const work = !chat && (isWorkBackendModel(model2) || workSurface());
+      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: lastVoiceLaunchProductExperience() ?? "unset"
+        productExperience: experience ?? "unset"
       });
       if (!gateway) {
         if (!external && !work)
@@ -16317,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,
@@ -16334,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, {
@@ -16362,7 +16454,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const config2 = readCpaLiveVoiceHookConfig(target);
     if (!config2) return { status: "disabled", dispose() {
     } };
-    if (config2.desktopVersion !== void 0 && config2.desktopVersion !== CLIENT_OWNED_VOICE_VERSION)
+    if (!supportsVoiceVersion(CLIENT_OWNED_VOICE_ASSETS, config2.desktopVersion))
       return { status: "unsupported", dispose() {
       } };
     const importModule = options.importModule ?? ((url2) => import(url2));
@@ -16383,25 +16475,26 @@ 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;
-          if (typeof module.frt !== "function") throw new Error();
-          module.frt();
-          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)
@@ -16489,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();
 })();