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

package/app/renderer-extension.js

@@ -6,104 +6,6 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../desktop-control/dist/renderer-react-ownership.js
-  var REACT_FIBER_WALK_LIMIT_EVENT = "codexhost:react-fiber-walk-limit";
-  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-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);
-  }
-
   // ../../node_modules/zod/v4/classic/external.js
   var external_exports = {};
   __export(external_exports, {
@@ -14990,6 +14892,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",
@@ -15530,7 +15434,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
@@ -15730,6 +15636,28 @@ 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 GROK_COMPUTER_USE_GET_METHOD = "codexhost/harness/grok-computer-use/get";
+  var GROK_COMPUTER_USE_SET_METHOD = "codexhost/harness/grok-computer-use/set";
+  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 HARNESS_INSTALLATION_METHOD = "codexhost/harness/installation";
   var harnessInstallationParamsSchema = external_exports.object({
@@ -16157,6 +16085,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 
   // ../shared-contracts/dist/voice-settings.js
   var VOICE_SETTINGS_METHOD = "codexhost/voice/settings";
+  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"]),
@@ -16206,7 +16135,17 @@ 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()
+  };
+  function applyVoiceGatewayReadiness(owner, ready) {
+    gatewayReady.set(owner, ready);
+  }
+  function voiceGatewayIsReady(owner) {
+    return gatewayReady.get(owner) === true;
+  }
   var SHARED_VOICE_CACHE = "codexhost.voice-routes-cache.v1";
   function cachedRoutes(owner) {
     const memory = sharedRoutes.get(owner);
@@ -16242,9 +16181,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return routes ? routes.chatExperience === "chatgpt" : !readFlag(owner, CHAT_LIVE_VOICE_STORAGE_KEY, false);
   }
   function legacyVoiceRoutes(owner) {
+    const chatLegacy = readFlag(owner, CHAT_LIVE_VOICE_STORAGE_KEY, false);
     return {
-      chatExperience: readFlag(owner, CHAT_LIVE_VOICE_STORAGE_KEY, false) ? "codex" : "chatgpt",
-      chatConnection: readFlag(owner, CHAT_LIVE_VOICE_STORAGE_KEY, false) ? "gateway" : "desktop",
+      chatExperience: chatLegacy ? "codex" : "chatgpt",
+      chatConnection: chatLegacy ? "gateway" : "desktop",
       workConnection: readFlag(owner, CPA_LIVE_VOICE_STORAGE_KEY, true) ? "gateway" : "desktop"
     };
   }
@@ -16406,265 +16346,885 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return handle;
   }
 
-  // src/agent-selection-state.ts
-  var DEFAULT_RENDERER_AGENTS = ["codex"];
-  function defaultIdFactory(sequence) {
-    return `codexhost-composer-${Date.now().toString(36)}-${sequence.toString(36)}`;
-  }
-  function isDefaultTarget(target) {
-    return target?.[0] === "default";
+  // src/renderer-voice-assets.ts
+  function supportsVoiceVersion(profiles, version2) {
+    return version2 === void 0 || profiles.some((profile) => profile.version === version2);
   }
-  function isConversationTarget(target) {
-    return target?.[0] === "conversation";
-  }
-  function isIdentifiedTarget(target) {
-    return target?.[0] === "conversation" || target?.[0] === "default" && typeof target[1] === "string" && target[1].startsWith("client-new-thread:");
-  }
-  function sameTarget(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
+  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;
   }
-  var DraftAgentController = class {
-    #idFactory;
-    #defaultAgent;
-    #enabledAgents;
-    #targetStates = [];
-    #modelRequestGenerations = /* @__PURE__ */ new WeakMap();
-    #ownershipRequestGenerations = /* @__PURE__ */ new WeakMap();
-    #states = /* @__PURE__ */ new WeakMap();
-    #switching = /* @__PURE__ */ new Set();
-    #pendingSubmissions = /* @__PURE__ */ new Set();
-    #composerSequence = 0;
-    #modelRequestSequence = 0;
-    #ownershipRequestSequence = 0;
-    #lastSubmittedAgent;
-    constructor(options = {}) {
-      this.#idFactory = options.idFactory ?? defaultIdFactory;
-      this.#enabledAgents = new Set(options.enabledAgents ?? DEFAULT_RENDERER_AGENTS);
-      if (!this.#enabledAgents.has("codex"))
-        throw new Error("Renderer enabled Agents must include Codex");
-      this.#defaultAgent = options.defaultAgent ?? "codex";
-      this.#lastSubmittedAgent = this.#defaultAgent;
-    }
-    setEnabledAgents(agents) {
-      this.#enabledAgents = /* @__PURE__ */ new Set(["codex", ...agents]);
-    }
-    get(composer) {
-      return this.#state(composer);
-    }
-    detach(composer, preservePendingSubmission = false) {
-      const state = this.#states.get(composer);
-      if (state && !preservePendingSubmission) this.#pendingSubmissions.delete(state);
-      this.#states.delete(composer);
+
+  // ../desktop-control/dist/renderer-react-ownership.js
+  var REACT_FIBER_WALK_LIMIT_EVENT = "codexhost:react-fiber-walk-limit";
+  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);
     }
-    mount(composer, target, preferredNewThreadAgent) {
-      const bound = this.#targetState(target);
-      if (bound) {
-        this.#states.set(composer, bound);
-        return bound;
+    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);
       }
-      const preferredAgent = preferredNewThreadAgent ?? this.#lastSubmittedAgent;
-      const state = this.#state(composer, isDefaultTarget(target) ? preferredAgent : "codex");
-      if (isIdentifiedTarget(target)) this.#targetStates.push({ target, state });
-      return state;
-    }
-    isSwitching(composer) {
-      return this.#switching.has(this.#state(composer));
-    }
-    beginModelRequest(composer) {
-      const state = this.#state(composer);
-      const generation = ++this.#modelRequestSequence;
-      this.#modelRequestGenerations.set(state, generation);
-      return generation;
-    }
-    invalidateModelRequests(composer) {
-      this.beginModelRequest(composer);
-    }
-    isCurrentModelRequest(composer, generation) {
-      return (this.#modelRequestGenerations.get(this.#state(composer)) ?? 0) === generation;
-    }
-    beginOwnershipRequest(composer) {
-      const generation = ++this.#ownershipRequestSequence;
-      this.#ownershipRequestGenerations.set(this.#state(composer), generation);
-      return generation;
-    }
-    isCurrentOwnershipRequest(composer, generation) {
-      return (this.#ownershipRequestGenerations.get(this.#state(composer)) ?? 0) === generation;
+      if (!matched || !child)
+        break;
+      path.push(child);
     }
-    rebindConversation(composer, target) {
-      if (!isConversationTarget(target)) return null;
-      const previous = this.#state(composer);
-      this.#pendingSubmissions.delete(previous);
-      this.#modelRequestGenerations.set(previous, ++this.#modelRequestSequence);
-      this.#ownershipRequestGenerations.set(previous, ++this.#ownershipRequestSequence);
-      let state = this.#targetState(target);
-      if (!state) {
-        state = {
-          agent: "codex",
-          phase: "draft",
-          composerId: this.#idFactory(++this.#composerSequence)
-        };
-        this.#targetStates.push({ target, state });
-      }
-      this.#states.set(composer, state);
-      this.#modelRequestGenerations.set(state, ++this.#modelRequestSequence);
-      this.#ownershipRequestGenerations.set(state, ++this.#ownershipRequestSequence);
-      return state;
+    if (path.length === previous.length && (path.at(-1) === first || path.at(-1) === alternate)) {
+      return path.reverse();
     }
-    restore(composer, agent, model2, thinkingOptionId, permissionModeId) {
-      const state = this.#state(composer);
-      this.#pendingSubmissions.delete(state);
-      state.agent = agent;
-      state.phase = "locked";
-      if (agent !== "codex") {
-        state.configurationByAgent = {
-          ...state.configurationByAgent,
-          [agent]: {
-            ...model2 ? { model: model2 } : {},
-            ...thinkingOptionId ? { thinkingOptionId } : {},
-            ...permissionModeId ? { permissionModeId } : {}
-          }
-        };
+    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;
       }
-      return state;
-    }
-    clearConfiguration(composer) {
-      delete this.#state(composer).configurationByAgent;
-    }
-    modelForAgent(composer, agent) {
-      return this.#state(composer).configurationByAgent?.[agent]?.model;
-    }
-    thinkingOptionForAgent(composer, agent) {
-      return this.#state(composer).configurationByAgent?.[agent]?.thinkingOptionId;
-    }
-    permissionModeForAgent(composer, agent) {
-      return this.#state(composer).configurationByAgent?.[agent]?.permissionModeId;
-    }
-    setExternalPermissionMode(composer, agent, permissionModeId) {
-      return this.#configure(composer, agent, { permissionModeId });
-    }
-    setExternalModel(composer, agent, model2) {
-      return this.#configure(composer, agent, { model: model2 });
+      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 });
     }
-    setExternalThinkingOption(composer, agent, thinkingOptionId) {
-      const state = this.#configure(composer, agent, {});
-      const configuration = state.configurationByAgent?.[agent];
-      if (!configuration) return state;
-      if (thinkingOptionId) configuration.thinkingOptionId = thinkingOptionId;
-      else delete configuration.thinkingOptionId;
-      return state;
+    return stack.length > 0 ? exhausted() : [];
+  }
+
+  // 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 {
     }
-    #configure(composer, agent, patch) {
-      const state = this.#state(composer);
-      state.configurationByAgent = {
-        ...state.configurationByAgent,
-        [agent]: { ...state.configurationByAgent?.[agent], ...patch }
+    owner.console?.info?.("[codexhost-chat-voice]", event, detail);
+  }
+
+  // src/renderer-native-chat-voice-state.ts
+  function observeNativeChatVoiceState(scope, initial) {
+    const store = Reflect.apply(initial.SPn, void 0, [
+      scope
+    ]);
+    let last = "";
+    const report = () => {
+      const state = store.getState();
+      const connection = state.server?.connectionState;
+      const detail = {
+        active: state.isVoiceModeActive === true,
+        connectedOnce: state.hasConnectedOnce === true,
+        sessionStarted: state.hasVoiceSessionStarted === true,
+        serverConversationReady: typeof state.earlyServerThreadId === "string" && /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i.test(state.earlyServerThreadId),
+        connection: typeof connection === "string" && ["disconnected", "connecting", "connected", "reconnecting", "signalReconnecting"].includes(
+          connection
+        ) ? connection : "unknown"
       };
-      return state;
-    }
-    lock(composer) {
-      const state = this.#state(composer);
-      this.#pendingSubmissions.delete(state);
-      state.phase = "locked";
-      return state;
-    }
-    markSubmissionPending(composer) {
-      const state = this.#state(composer);
-      if (state.phase === "draft") this.#pendingSubmissions.add(state);
-      return state;
-    }
-    isSubmissionPending(composer) {
-      return this.#pendingSubmissions.has(this.#state(composer));
-    }
-    clearPendingSubmission(composer) {
-      this.#pendingSubmissions.delete(this.#state(composer));
-    }
-    recordSubmission(composer) {
-      const state = this.#state(composer);
-      this.#lastSubmittedAgent = state.agent;
-      return state;
-    }
-    transfer(source, replacement, target = null) {
-      const state = this.#states.get(source);
-      if (!state) return false;
-      const bound = this.#targetState(target);
-      if (bound && bound !== state) return false;
-      if (source !== replacement) {
-        if (this.#states.has(replacement)) return false;
-        this.#states.set(replacement, state);
-      }
-      if (isIdentifiedTarget(target) && !bound) this.#targetStates.push({ target, state });
-      if (isConversationTarget(target) && this.#pendingSubmissions.delete(state))
-        state.phase = "locked";
-      return true;
-    }
-    async switchAgent(composer, nextAgent, operations) {
-      const state = this.#state(composer);
-      if (!this.#enabledAgents.has(nextAgent)) return false;
-      if (state.phase !== "draft" || this.#switching.has(state)) return false;
-      if (state.agent === nextAgent) return true;
-      this.#pendingSubmissions.delete(state);
-      this.#switching.add(state);
+      const next = JSON.stringify(detail);
+      if (next === last) return;
+      last = next;
+      chatVoiceDebug("native-chat-state", detail);
+    };
+    const unsubscribe = store.subscribe(report);
+    report();
+    return unsubscribe;
+  }
+
+  // src/renderer-native-chat-voice-selection.ts
+  var UUID = /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i;
+  function nativeChatVoiceDraftSelection(binding, initial, shared, origin, signal) {
+    const draft = binding.props.conversationId;
+    const navigate = initial.Nir;
+    const conversationPath = shared.Vot;
+    if (binding.backendConversationId !== void 0 || !draft.startsWith("local-chatgpt:") || !UUID.test(draft.slice("local-chatgpt:".length)) || origin == null || initial.Ycr == null || initial.n0n == null || initial.Y1n == null || typeof navigate !== "function" || typeof conversationPath !== "function")
+      return () => {
+      };
+    const store = Reflect.apply(initial.SPn, void 0, [
+      binding.scope
+    ]);
+    const stateAtStart = store.getState();
+    const readIntentVersion = typeof initial.HJt === "function" ? () => Reflect.apply(initial.HJt, void 0, [binding.scope]) : void 0;
+    const version2 = readIntentVersion?.();
+    const intentVersion = typeof version2 === "number" && Number.isSafeInteger(version2) && version2 > 0 ? version2 : void 0;
+    let session = stateAtStart.voiceSessionId;
+    let activeSeen = stateAtStart.isVoiceModeActive;
+    let sessionStartedSeen = stateAtStart.hasVoiceSessionStarted;
+    let finished = false;
+    return () => {
+      if (finished) return;
       try {
-        if (!operations.applyAgent(nextAgent)) return false;
-        try {
-          await operations.clearPrewarm();
-        } catch (error51) {
-          if (!operations.applyAgent(state.agent))
-            throw new Error("Draft Agent switch could not restore the prior Agent", { cause: error51 });
-          return false;
+        const state = store.getState();
+        if (signal.aborted || binding.scope.get(initial.Ycr) !== origin || intentVersion !== void 0 && readIntentVersion?.() !== intentVersion || activeSeen && (!state.isVoiceModeActive || state.voiceSessionId !== session && (sessionStartedSeen || intentVersion === void 0))) {
+          finished = true;
+          return;
         }
-        state.agent = nextAgent;
-        return true;
-      } finally {
-        this.#switching.delete(state);
+        if (!state.isVoiceModeActive) return;
+        if (!activeSeen) {
+          session = state.voiceSessionId;
+          activeSeen = true;
+        }
+        if (session !== state.voiceSessionId) {
+          session = state.voiceSessionId;
+          chatVoiceDebug("native-chat-selection-startup-id-adopted");
+        }
+        sessionStartedSeen ||= state.hasVoiceSessionStarted;
+        if (state.isWorkMode !== false || state.conversationId !== draft) {
+          finished = true;
+          return;
+        }
+        if (!state.hasVoiceSessionStarted || state.server.connectionState !== "connected") return;
+        const backend = binding.scope.get(initial.B1n, draft);
+        if (typeof backend !== "string" || !UUID.test(backend)) return;
+        const mapping = binding.scope.get(initial.n0n, draft);
+        const currentNode = binding.scope.get(initial.Y1n, draft);
+        if (mapping == null || typeof mapping !== "object" || typeof currentNode !== "string" || !mapping[currentNode]?.message)
+          return;
+        finished = true;
+        const path = Reflect.apply(conversationPath, void 0, [draft]);
+        const accepted = Reflect.apply(navigate, void 0, [binding.scope, path]);
+        void Promise.resolve(accepted).then(
+          (result) => chatVoiceDebug(
+            result === false ? "native-chat-selection-declined" : "native-chat-draft-selection-requested"
+          ),
+          () => chatVoiceDebug("native-chat-selection-failed")
+        );
+      } catch {
+        finished = true;
+        chatVoiceDebug("native-chat-selection-failed");
       }
-    }
-    #targetState(target) {
-      if (!isIdentifiedTarget(target)) return null;
-      return this.#targetStates.find((candidate) => sameTarget(candidate.target, target))?.state ?? null;
-    }
-    #state(composer, initialAgent) {
-      const existing = this.#states.get(composer);
-      if (existing) return existing;
-      const created = {
-        agent: initialAgent ?? this.#defaultAgent,
-        phase: "draft",
-        composerId: this.#idFactory(++this.#composerSequence)
-      };
-      this.#states.set(composer, created);
-      return created;
-    }
-  };
-
-  // src/renderer-new-thread-preference.ts
-  var RENDERER_NEW_THREAD_PREFERENCE_KEY = "codexhost.new-thread-preference.v1";
-  function rendererNewThreadPreferenceStorage(hostId2 = "local") {
-    if (!hostId2) return null;
-    try {
-      const storage = window.localStorage;
-      if (hostId2 === "local") return storage;
-      const scopedKey = (key) => `${key}.host.${encodeURIComponent(hostId2)}`;
-      return {
-        getItem: (key) => storage.getItem(scopedKey(key)),
-        setItem: (key, value) => storage.setItem(scopedKey(key), value)
-      };
-    } catch {
-      return null;
-    }
+    };
   }
-  function isRecord2(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+
+  // src/renderer-native-chat-voice-presentation.ts
+  function alignNativeChatVoiceButton(button2, send, doc) {
+    const parent = send.parentElement;
+    if (!parent) return;
+    const layout = doc.defaultView?.getComputedStyle(parent);
+    const gap = layout && /flex|grid/.test(layout.display) ? Number.parseFloat(layout.columnGap) || 0 : 0;
+    const margin = `max(0px, calc(var(--spacing, 0.25rem) * 2 - ${gap}px))`;
+    if (button2.style.marginInlineEnd !== margin) button2.style.marginInlineEnd = margin;
+    if (button2.style.alignSelf !== "center") button2.style.alignSelf = "center";
   }
-  function parseExternalConfiguration(value) {
-    if (!isRecord2(value)) return void 0;
-    const model2 = harnessModelRefSchema.safeParse(value.model);
-    if (!model2.success) return void 0;
-    const thinkingOptionId = harnessThinkingOptionIdSchema.safeParse(value.thinkingOptionId);
-    const permissionModeId = harnessPermissionModeIdSchema.safeParse(value.permissionModeId);
-    return {
-      model: model2.data,
-      ...thinkingOptionId.success ? { thinkingOptionId: thinkingOptionId.data } : {},
-      ...permissionModeId.success ? { permissionModeId: permissionModeId.data } : {}
+  function hideNativeChatVoiceHomeHeadline(doc) {
+    const headlines = [
+      ...doc.querySelectorAll('[style*="--vt-splash-screen-headline"]')
+    ].filter(
+      (element) => element.querySelector("h1 [data-headline]") && element.getBoundingClientRect().width > 0 && !element.closest("[hidden], [inert]")
+    );
+    if (headlines.length !== 1) return;
+    const headline = headlines[0];
+    if (!headline) return;
+    const previous = headline.style.getPropertyValue("visibility");
+    const priority = headline.style.getPropertyPriority("visibility");
+    headline.style.setProperty("visibility", "hidden", "important");
+    return () => {
+      if (headline.style.getPropertyValue("visibility") === "hidden" && headline.style.getPropertyPriority("visibility") === "important")
+        headline.style.setProperty("visibility", previous, priority);
+    };
+  }
+
+  // src/renderer-native-chat-voice.ts
+  var HOOK_GLOBAL = "__codexhostNativeChatVoiceV1";
+  var NATIVE_CHAT_VOICE_VERSION = "26.1016.62342";
+  var NATIVE_CHAT_INITIAL_ASSET = "app-initial-dddef47d6ef6.js";
+  var NATIVE_CHAT_SHARED_ASSET = "app-shared-fc3316d48427.js";
+  var START_ASSET = "start-voice-7cbf0a39d53b.js";
+  var PREWARM_ASSET = "voice-prewarm-5d107129ac1c.js";
+  var NATIVE_CHAT_VOICE_ASSETS = [
+    {
+      version: NATIVE_CHAT_VOICE_VERSION,
+      initial: NATIVE_CHAT_INITIAL_ASSET,
+      shared: NATIVE_CHAT_SHARED_ASSET,
+      start: START_ASSET,
+      prewarm: PREWARM_ASSET
+    },
+    {
+      version: "26.1016.61520",
+      initial: "app-initial-c95ddb62696e.js",
+      shared: "app-shared-2eda13eb7044.js",
+      start: "start-voice-18b08f0acdd7.js",
+      prewarm: "voice-prewarm-94271e581c1b.js"
+    }
+  ];
+  var BUTTON = "data-codexhost-chat-voice-start";
+  var CONVERSATION_UUID = /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i;
+  var record2 = (value) => value !== null && typeof value === "object";
+  function scopeRefs(owner, definition) {
+    const scopes = /* @__PURE__ */ new Map();
+    let hook = owner.memoizedState;
+    const seen = /* @__PURE__ */ new Set();
+    while (record2(hook) && seen.size < 4096 && !seen.has(hook)) {
+      seen.add(hook);
+      const state = hook.memoizedState;
+      const scope = record2(state) ? state.current : void 0;
+      if (record2(scope) && scope.scope === definition && typeof scope.get === "function" && typeof scope.set === "function" && scope.chain instanceof Map && scope.chain.get(definition.id) === scope.node)
+        scopes.set(scope.node, scope);
+      hook = hook.next;
+    }
+    return hook == null ? scopes : /* @__PURE__ */ new Map();
+  }
+  function detectNativeChatVoiceBinding(composer, native) {
+    const key = Object.getOwnPropertyNames(composer).find((key2) => key2.startsWith("__reactFiber$"));
+    if (!key) return;
+    const ancestors = committedReactAncestors(Object.getOwnPropertyDescriptor(composer, key)?.value);
+    for (const owner of ancestors) {
+      const props = owner.memoizedProps;
+      if (!record2(props) || typeof props.isWorkConversation !== "boolean" || typeof props.isTemporaryChat !== "boolean" || typeof props.conversationId !== "string")
+        continue;
+      if (props.isWorkConversation || props.isTemporaryChat || props.shouldBlockExternalEgress !== false || props.readOnly === true || !record2(props.composerSelectionContext) || props.composerSelectionContext.conversationId !== props.conversationId)
+        return;
+      const scopes = scopeRefs(owner, native.ownerScopeDefinition);
+      if (scopes.size !== 1) return;
+      const scope = [...scopes.values()][0];
+      if (!scope) return;
+      const appNode = scope.chain.get(native.scopeDefinition.id);
+      if (!record2(appNode)) return;
+      const backendId = scope.get(native.backendConversationId, props.conversationId);
+      const hasBackendId = typeof backendId === "string" && CONVERSATION_UUID.test(backendId);
+      const isDraft = backendId == null && props.conversationId.startsWith("local-chatgpt:") && CONVERSATION_UUID.test(props.conversationId.slice("local-chatgpt:".length));
+      if (!hasBackendId && !isDraft) return;
+      const provider = ancestors.slice(0, ancestors.indexOf(owner)).find(
+        (fiber) => fiber.tag === 10 && record2(fiber.type) && fiber.type.displayName === native.composerScopeDefinition.__scopeBrand
+      );
+      if (!provider) return;
+      const composerChain = record2(provider.memoizedProps) ? provider.memoizedProps.value : void 0;
+      const composerNode = composerChain instanceof Map ? composerChain.get(native.composerScopeDefinition.id) : void 0;
+      if (!(composerChain instanceof Map) || composerChain.get(native.scopeDefinition.id) !== appNode || composerChain.get(native.ownerScopeDefinition.id) !== scope.node || !record2(composerNode) || composerNode.token !== native.composerScopeDefinition || !record2(composerNode.value) || composerNode.value.kind !== "chatgpt" || !record2(composerNode.value.chatGptSelectionContext) || composerNode.value.chatGptSelectionContext.conversationId !== props.conversationId)
+        return;
+      const composerContext = { context: provider.type, chain: composerChain };
+      const contexts = /* @__PURE__ */ new Set();
+      for (const fiber of ancestors) {
+        let dependency = record2(fiber.dependencies) ? fiber.dependencies.firstContext : void 0;
+        const seenDependencies = /* @__PURE__ */ new Set();
+        while (record2(dependency) && seenDependencies.size < 4096 && !seenDependencies.has(dependency)) {
+          seenDependencies.add(dependency);
+          const context = dependency.context;
+          const chain = dependency.memoizedValue;
+          if (record2(context) && context.displayName === native.scopeDefinition.__scopeBrand && chain instanceof Map && chain.get(native.scopeDefinition.id) === appNode)
+            contexts.add(context);
+          dependency = dependency.next;
+        }
+      }
+      if (contexts.size !== 1) return;
+      return {
+        composer,
+        appNode,
+        props,
+        scope,
+        context: [...contexts][0],
+        composerContext,
+        backendConversationId: hasBackendId ? backendId : void 0
+      };
+    }
+  }
+  function startNativeChatVoiceForRequest(request, target = globalThis) {
+    if (!record2(request) || request.productExperience !== "chat" || !nativeChatVoicePreferenceAllowsStart(target))
+      return;
+    const hook = target[HOOK_GLOBAL];
+    if (!hook || hook.status === "disabled" || hook.status === "unsupported")
+      return Promise.reject(new Error("Native Chat voice is unavailable"));
+    return hook.start();
+  }
+  function installNativeChatVoiceHook(options = {}) {
+    const target = options.target ?? globalThis;
+    const existing = target[HOOK_GLOBAL];
+    if (existing) return existing;
+    const config2 = readCpaLiveVoiceHookConfig(target);
+    const unavailable = (status) => ({
+      status,
+      dispose() {
+      },
+      start: async () => {
+        throw new Error("Native Chat voice is unavailable");
+      }
+    });
+    if (!config2) return unavailable("disabled");
+    if (!supportsVoiceVersion(NATIVE_CHAT_VOICE_ASSETS, config2.desktopVersion))
+      return unavailable("unsupported");
+    const doc = target.document;
+    if (!doc) return unavailable("unsupported");
+    const importModule = options.importModule ?? ((url2) => import(url2));
+    let disposed = false;
+    let timer;
+    let modules;
+    let boundScope;
+    let mounted;
+    let button2;
+    const overlayButtons = /* @__PURE__ */ new Map();
+    let controller;
+    let starting = false;
+    let selectDraft;
+    let restoreHeadline;
+    let renderFailed = false;
+    const started = Date.now();
+    const showHeadline = () => {
+      restoreHeadline?.();
+      restoreHeadline = void 0;
+    };
+    const removeButton = () => {
+      button2?.remove();
+      button2 = void 0;
+      for (const [control, [display, priority]] of overlayButtons)
+        if (control.style.getPropertyValue("display") === "none" && control.style.getPropertyPriority("display") === "important")
+          control.style.setProperty("display", display, priority);
+      overlayButtons.clear();
+    };
+    const release = () => {
+      showHeadline();
+      selectDraft = void 0;
+      controller?.abort();
+      controller = void 0;
+      removeButton();
+      mounted?.dispose();
+      mounted = void 0;
+      boundScope = void 0;
+    };
+    const findBinding = () => {
+      if (!modules || !nativeChatVoicePreferenceAllowsStart(target)) return;
+      const forms = [...doc.querySelectorAll("[data-chatgpt-composer]")].filter(
+        (form2) => form2.getBoundingClientRect().width > 0 && !form2.closest("[hidden], [inert]")
+      );
+      if (forms.length !== 1) return;
+      const form = forms[0];
+      if (!form) return;
+      return detectNativeChatVoiceBinding(form, {
+        scopeDefinition: modules.shared.Qst,
+        ownerScopeDefinition: modules.initial.MOr,
+        backendConversationId: modules.initial.B1n,
+        composerScopeDefinition: modules.initial.CDr
+      });
+    };
+    const handle = {
+      get activeCall() {
+        if (starting) return true;
+        if (!boundScope || !modules || typeof modules.initial.SPn !== "function") return false;
+        try {
+          return modules.initial.SPn(boundScope).getState().isVoiceModeActive;
+        } catch {
+          return false;
+        }
+      },
+      status: "pending",
+      async start() {
+        if (disposed || starting) return;
+        const current = findBinding();
+        if (!current || !modules || current.appNode !== mounted?.node)
+          throw new Error("Select a ChatGPT conversation to start Chat voice");
+        starting = true;
+        controller = new AbortController();
+        const signal = controller.signal;
+        let origin;
+        try {
+          if (modules.initial.Ycr != null) origin = current.scope.get(modules.initial.Ycr);
+        } catch {
+          chatVoiceDebug("native-chat-selection-failed");
+        }
+        selectDraft = void 0;
+        chatVoiceDebug("native-chat-start", {
+          hasConversationId: current.backendConversationId !== void 0
+        });
+        try {
+          await Reflect.apply(modules.start.n, void 0, [
+            current.scope,
+            current.props,
+            { event_source: "composer" },
+            signal
+          ]);
+          chatVoiceDebug("native-chat-start-returned");
+          try {
+            selectDraft = nativeChatVoiceDraftSelection(
+              current,
+              modules.initial,
+              modules.shared,
+              origin,
+              signal
+            );
+            selectDraft();
+          } catch {
+            chatVoiceDebug("native-chat-selection-failed");
+          }
+        } catch {
+          chatVoiceDebug("native-chat-start-failed");
+          throw new Error("Native Chat voice could not start");
+        } finally {
+          starting = false;
+        }
+      },
+      dispose() {
+        disposed = true;
+        if (timer !== void 0) target.clearTimeout(timer);
+        release();
+        if (target[HOOK_GLOBAL] === handle) Reflect.deleteProperty(target, HOOK_GLOBAL);
+      }
+    };
+    target[HOOK_GLOBAL] = handle;
+    const refresh = async () => {
+      if (disposed) return;
+      try {
+        if (renderFailed) throw new Error();
+        if (!modules) {
+          const names = loadedAssetNames(doc, target.performance);
+          const assets = selectVoiceAssets(NATIVE_CHAT_VOICE_ASSETS, names, config2.desktopVersion);
+          if (!assets) {
+            if (Date.now() - started >= 6e4) {
+              handle.status = "unsupported";
+              return;
+            }
+            return;
+          }
+          const [shared, initial, start, prewarm] = await Promise.all(
+            [assets.shared, assets.initial, assets.start, assets.prewarm].map(
+              (asset) => importModule(`app://-/assets/${asset}`)
+            )
+          );
+          if (disposed) return;
+          if (!shared || !initial || !start || !prewarm || typeof start.t !== "function" || typeof start.n !== "function" || typeof initial.oT !== "function" || typeof initial.SPn !== "function" || typeof shared.FBt !== "function" || typeof shared.PNt !== "function" || typeof prewarm.VoiceInstantConnectCacheController !== "function")
+            throw new Error();
+          initial.oT();
+          start.t();
+          if (!record2(shared.Qst) || !record2(initial.MOr) || !initial.B1n || !initial.aT || !record2(initial.CDr))
+            throw new Error();
+          modules = { shared, initial, start, prewarm };
+        }
+        const current = findBinding();
+        selectDraft?.();
+        if (!current) {
+          showHeadline();
+          if (handle.activeCall) return;
+          release();
+          handle.status = "pending";
+          return;
+        }
+        if (mounted && current.appNode !== mounted.node) release();
+        boundScope = current.scope;
+        if (!mounted) {
+          const { scope } = current;
+          const initial = modules.initial;
+          const previous = scope.get(initial.aT);
+          const container = doc.createElement("div");
+          container.setAttribute("data-codexhost-chat-voice-prewarm", "");
+          doc.body.append(container);
+          const react = Reflect.apply(modules.shared.FBt, void 0, []);
+          const reactDom = Reflect.apply(modules.shared.PNt, void 0, []);
+          const root = reactDom.createRoot(container, {
+            onUncaughtError() {
+              renderFailed = true;
+            }
+          });
+          const stopObserving = observeNativeChatVoiceState(scope, initial);
+          let appChain;
+          let composerChain;
+          mounted = {
+            node: current.appNode,
+            render(next) {
+              if (appChain === next.scope.chain && composerChain === next.composerContext.chain)
+                return;
+              appChain = next.scope.chain;
+              composerChain = next.composerContext.chain;
+              root.render(
+                react.createElement(
+                  next.context,
+                  { value: appChain },
+                  react.createElement(
+                    next.composerContext.context,
+                    { value: composerChain },
+                    react.createElement(modules?.prewarm.VoiceInstantConnectCacheController, null)
+                  )
+                )
+              );
+            },
+            dispose() {
+              stopObserving();
+              root.unmount();
+              container.remove();
+              if (scope.get(initial.aT) === true) scope.set(initial.aT, previous);
+              chatVoiceDebug("native-chat-unbound");
+            }
+          };
+          scope.set(initial.aT, true);
+          chatVoiceDebug("native-chat-bound", {
+            hasConversationId: current.backendConversationId !== void 0
+          });
+        }
+        mounted.render(current);
+        const voiceState = Reflect.apply(modules.initial.SPn, void 0, [
+          current.scope
+        ]).getState();
+        if (current.props.conversationId.startsWith("local-chatgpt:") && voiceState.isVoiceModeActive && voiceState.isWorkMode === false && voiceState.conversationId === current.props.conversationId)
+          restoreHeadline ??= hideNativeChatVoiceHomeHeadline(doc);
+        else showHeadline();
+        const sends = [
+          ...current.composer.querySelectorAll('button[type="submit"]')
+        ].filter(
+          (control) => control.getBoundingClientRect().width > 0 && !control.closest("[hidden], [inert]")
+        );
+        const send = sends.length === 1 ? sends[0] : void 0;
+        if (!send?.parentElement) removeButton();
+        else {
+          if (!button2 || !current.composer.contains(button2)) {
+            removeButton();
+            button2 = doc.createElement("button");
+            button2.type = "button";
+            button2.setAttribute(BUTTON, "");
+            button2.setAttribute("aria-label", "Start Voice");
+            button2.title = "Start Voice";
+            button2.innerHTML = '<svg class="icon-primary-action text-composer-primary" width="20" height="20" viewBox="0 0 20 20" fill="none" aria-hidden="true"><path d="M3 8v4m4-7v10m6-12v14m4-9v4" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>';
+            button2.addEventListener("click", () => {
+              void handle.start().catch(() => {
+                if (button2) button2.title = "Chat voice could not start. Try again.";
+              });
+            });
+          }
+          if (button2.nextElementSibling !== send) send.parentElement.insertBefore(button2, send);
+          alignNativeChatVoiceButton(button2, send, doc);
+        }
+        if (button2)
+          for (const control of current.composer.querySelectorAll(
+            'button[aria-label="Start new voice chat"], button[aria-label="Start voice chat"]'
+          )) {
+            if (!overlayButtons.has(control))
+              overlayButtons.set(control, [
+                control.style.getPropertyValue("display"),
+                control.style.getPropertyPriority("display")
+              ]);
+            control.style.setProperty("display", "none", "important");
+          }
+        if (button2 && send) {
+          button2.disabled = starting || current.props.isStreaming === true || voiceState.isVoiceModeActive;
+          const className = [
+            ...send.className.split(/\s+/).filter((name) => name !== "opacity-50" && name !== "cursor-default"),
+            ...button2.disabled ? ["opacity-50", "cursor-default"] : []
+          ].join(" ");
+          if (button2.className !== className) button2.className = className;
+        }
+        handle.status = "active";
+      } catch {
+        release();
+        handle.status = "unsupported";
+        chatVoiceDebug("native-chat-binding-failed");
+        return;
+      } finally {
+        if (!disposed && handle.status !== "unsupported")
+          timer = target.setTimeout(() => void refresh(), 500);
+      }
+    };
+    void refresh();
+    return handle;
+  }
+
+  // src/agent-selection-state.ts
+  var DEFAULT_RENDERER_AGENTS = ["codex"];
+  function defaultIdFactory(sequence) {
+    return `codexhost-composer-${Date.now().toString(36)}-${sequence.toString(36)}`;
+  }
+  function isDefaultTarget(target) {
+    return target?.[0] === "default";
+  }
+  function isConversationTarget(target) {
+    return target?.[0] === "conversation";
+  }
+  function isIdentifiedTarget(target) {
+    return target?.[0] === "conversation" || target?.[0] === "default" && typeof target[1] === "string" && target[1].startsWith("client-new-thread:");
+  }
+  function sameTarget(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+  }
+  var DraftAgentController = class {
+    #idFactory;
+    #defaultAgent;
+    #enabledAgents;
+    #targetStates = [];
+    #modelRequestGenerations = /* @__PURE__ */ new WeakMap();
+    #ownershipRequestGenerations = /* @__PURE__ */ new WeakMap();
+    #states = /* @__PURE__ */ new WeakMap();
+    #switching = /* @__PURE__ */ new Set();
+    #pendingSubmissions = /* @__PURE__ */ new Set();
+    #composerSequence = 0;
+    #modelRequestSequence = 0;
+    #ownershipRequestSequence = 0;
+    #lastSubmittedAgent;
+    constructor(options = {}) {
+      this.#idFactory = options.idFactory ?? defaultIdFactory;
+      this.#enabledAgents = new Set(options.enabledAgents ?? DEFAULT_RENDERER_AGENTS);
+      if (!this.#enabledAgents.has("codex"))
+        throw new Error("Renderer enabled Agents must include Codex");
+      this.#defaultAgent = options.defaultAgent ?? "codex";
+      this.#lastSubmittedAgent = this.#defaultAgent;
+    }
+    setEnabledAgents(agents) {
+      this.#enabledAgents = /* @__PURE__ */ new Set(["codex", ...agents]);
+    }
+    get(composer) {
+      return this.#state(composer);
+    }
+    detach(composer, preservePendingSubmission = false) {
+      const state = this.#states.get(composer);
+      if (state && !preservePendingSubmission) this.#pendingSubmissions.delete(state);
+      this.#states.delete(composer);
+    }
+    mount(composer, target, preferredNewThreadAgent) {
+      const bound = this.#targetState(target);
+      if (bound) {
+        this.#states.set(composer, bound);
+        return bound;
+      }
+      const preferredAgent = preferredNewThreadAgent ?? this.#lastSubmittedAgent;
+      const state = this.#state(composer, isDefaultTarget(target) ? preferredAgent : "codex");
+      if (isIdentifiedTarget(target)) this.#targetStates.push({ target, state });
+      return state;
+    }
+    isSwitching(composer) {
+      return this.#switching.has(this.#state(composer));
+    }
+    beginModelRequest(composer) {
+      const state = this.#state(composer);
+      const generation = ++this.#modelRequestSequence;
+      this.#modelRequestGenerations.set(state, generation);
+      return generation;
+    }
+    invalidateModelRequests(composer) {
+      this.beginModelRequest(composer);
+    }
+    isCurrentModelRequest(composer, generation) {
+      return (this.#modelRequestGenerations.get(this.#state(composer)) ?? 0) === generation;
+    }
+    beginOwnershipRequest(composer) {
+      const generation = ++this.#ownershipRequestSequence;
+      this.#ownershipRequestGenerations.set(this.#state(composer), generation);
+      return generation;
+    }
+    isCurrentOwnershipRequest(composer, generation) {
+      return (this.#ownershipRequestGenerations.get(this.#state(composer)) ?? 0) === generation;
+    }
+    rebindConversation(composer, target) {
+      if (!isConversationTarget(target)) return null;
+      const previous = this.#state(composer);
+      this.#pendingSubmissions.delete(previous);
+      this.#modelRequestGenerations.set(previous, ++this.#modelRequestSequence);
+      this.#ownershipRequestGenerations.set(previous, ++this.#ownershipRequestSequence);
+      let state = this.#targetState(target);
+      if (!state) {
+        state = {
+          agent: "codex",
+          phase: "draft",
+          composerId: this.#idFactory(++this.#composerSequence)
+        };
+        this.#targetStates.push({ target, state });
+      }
+      this.#states.set(composer, state);
+      this.#modelRequestGenerations.set(state, ++this.#modelRequestSequence);
+      this.#ownershipRequestGenerations.set(state, ++this.#ownershipRequestSequence);
+      return state;
+    }
+    restore(composer, agent, model2, thinkingOptionId, permissionModeId) {
+      const state = this.#state(composer);
+      this.#pendingSubmissions.delete(state);
+      state.agent = agent;
+      state.phase = "locked";
+      if (agent !== "codex") {
+        state.configurationByAgent = {
+          ...state.configurationByAgent,
+          [agent]: {
+            ...model2 ? { model: model2 } : {},
+            ...thinkingOptionId ? { thinkingOptionId } : {},
+            ...permissionModeId ? { permissionModeId } : {}
+          }
+        };
+      }
+      return state;
+    }
+    clearConfiguration(composer) {
+      delete this.#state(composer).configurationByAgent;
+    }
+    modelForAgent(composer, agent) {
+      return this.#state(composer).configurationByAgent?.[agent]?.model;
+    }
+    thinkingOptionForAgent(composer, agent) {
+      return this.#state(composer).configurationByAgent?.[agent]?.thinkingOptionId;
+    }
+    permissionModeForAgent(composer, agent) {
+      return this.#state(composer).configurationByAgent?.[agent]?.permissionModeId;
+    }
+    setExternalPermissionMode(composer, agent, permissionModeId) {
+      return this.#configure(composer, agent, { permissionModeId });
+    }
+    setExternalModel(composer, agent, model2) {
+      return this.#configure(composer, agent, { model: model2 });
+    }
+    setExternalThinkingOption(composer, agent, thinkingOptionId) {
+      const state = this.#configure(composer, agent, {});
+      const configuration = state.configurationByAgent?.[agent];
+      if (!configuration) return state;
+      if (thinkingOptionId) configuration.thinkingOptionId = thinkingOptionId;
+      else delete configuration.thinkingOptionId;
+      return state;
+    }
+    #configure(composer, agent, patch) {
+      const state = this.#state(composer);
+      state.configurationByAgent = {
+        ...state.configurationByAgent,
+        [agent]: { ...state.configurationByAgent?.[agent], ...patch }
+      };
+      return state;
+    }
+    lock(composer) {
+      const state = this.#state(composer);
+      this.#pendingSubmissions.delete(state);
+      state.phase = "locked";
+      return state;
+    }
+    markSubmissionPending(composer) {
+      const state = this.#state(composer);
+      if (state.phase === "draft") this.#pendingSubmissions.add(state);
+      return state;
+    }
+    isSubmissionPending(composer) {
+      return this.#pendingSubmissions.has(this.#state(composer));
+    }
+    clearPendingSubmission(composer) {
+      this.#pendingSubmissions.delete(this.#state(composer));
+    }
+    recordSubmission(composer) {
+      const state = this.#state(composer);
+      this.#lastSubmittedAgent = state.agent;
+      return state;
+    }
+    transfer(source, replacement, target = null) {
+      const state = this.#states.get(source);
+      if (!state) return false;
+      const bound = this.#targetState(target);
+      if (bound && bound !== state) return false;
+      if (source !== replacement) {
+        if (this.#states.has(replacement)) return false;
+        this.#states.set(replacement, state);
+      }
+      if (isIdentifiedTarget(target) && !bound) this.#targetStates.push({ target, state });
+      if (isConversationTarget(target) && this.#pendingSubmissions.delete(state))
+        state.phase = "locked";
+      return true;
+    }
+    async switchAgent(composer, nextAgent, operations) {
+      const state = this.#state(composer);
+      if (!this.#enabledAgents.has(nextAgent)) return false;
+      if (state.phase !== "draft" || this.#switching.has(state)) return false;
+      if (state.agent === nextAgent) return true;
+      this.#pendingSubmissions.delete(state);
+      this.#switching.add(state);
+      try {
+        if (!operations.applyAgent(nextAgent)) return false;
+        try {
+          await operations.clearPrewarm();
+        } catch (error51) {
+          if (!operations.applyAgent(state.agent))
+            throw new Error("Draft Agent switch could not restore the prior Agent", { cause: error51 });
+          return false;
+        }
+        state.agent = nextAgent;
+        return true;
+      } finally {
+        this.#switching.delete(state);
+      }
+    }
+    #targetState(target) {
+      if (!isIdentifiedTarget(target)) return null;
+      return this.#targetStates.find((candidate) => sameTarget(candidate.target, target))?.state ?? null;
+    }
+    #state(composer, initialAgent) {
+      const existing = this.#states.get(composer);
+      if (existing) return existing;
+      const created = {
+        agent: initialAgent ?? this.#defaultAgent,
+        phase: "draft",
+        composerId: this.#idFactory(++this.#composerSequence)
+      };
+      this.#states.set(composer, created);
+      return created;
+    }
+  };
+
+  // src/renderer-new-thread-preference.ts
+  var RENDERER_NEW_THREAD_PREFERENCE_KEY = "codexhost.new-thread-preference.v1";
+  function rendererNewThreadPreferenceStorage(hostId2 = "local") {
+    if (!hostId2) return null;
+    try {
+      const storage = window.localStorage;
+      if (hostId2 === "local") return storage;
+      const scopedKey = (key) => `${key}.host.${encodeURIComponent(hostId2)}`;
+      return {
+        getItem: (key) => storage.getItem(scopedKey(key)),
+        setItem: (key, value) => storage.setItem(scopedKey(key), value)
+      };
+    } catch {
+      return null;
+    }
+  }
+  function isRecord2(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function parseExternalConfiguration(value) {
+    if (!isRecord2(value)) return void 0;
+    const model2 = harnessModelRefSchema.safeParse(value.model);
+    if (!model2.success) return void 0;
+    const thinkingOptionId = harnessThinkingOptionIdSchema.safeParse(value.thinkingOptionId);
+    const permissionModeId = harnessPermissionModeIdSchema.safeParse(value.permissionModeId);
+    return {
+      model: model2.data,
+      ...thinkingOptionId.success ? { thinkingOptionId: thinkingOptionId.data } : {},
+      ...permissionModeId.success ? { permissionModeId: permissionModeId.data } : {}
     };
   }
   function readPreference(storage) {
@@ -16747,14 +17307,34 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
 
   // 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 HOOK_GLOBAL = "__codexhostClientOwnedVoiceV1";
+  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_GLOBAL2 = "__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 = () => {
@@ -16777,7 +17357,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();
@@ -16802,24 +17382,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 document2 = owner.document;
+    if (!document2?.querySelectorAll) return false;
+    const work = [...document2.querySelectorAll("[data-codex-composer-root]")].some((element) => {
+      const box = element.getBoundingClientRect?.() ?? { width: 0 };
+      return box.width > 0 && !element.closest?.("[hidden], [inert]");
+    });
+    return work && document2.querySelectorAll("[data-chatgpt-composer]").length === 0;
+  }
+  function selectedWorkTab(owner) {
+    const document2 = owner.document;
+    if (!document2?.querySelectorAll) return false;
+    const controls = document2.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;
@@ -16844,579 +17450,147 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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")
-        return original.call(this, url2, options);
-      const chat = lastVoiceLaunchProductExperience() === "chat";
-      const model2 = backendModelName(options.headers);
-      const work = !chat && (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"
-      });
-      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();
-      let cancelled = false;
-      const cancel = () => {
-        if (cancelled) return;
-        cancelled = true;
-        void requestHost(bridge, { operation: "cancel", requestId: requestId2 }).catch(() => void 0);
-      };
-      options.signal?.addEventListener("abort", cancel, { once: true });
-      try {
-        const result = realtimeCallResponseSchema.parse(
-          await requestHost(bridge, {
-            operation: "create",
-            requestId: requestId2,
-            body: options.body,
-            // Drop Desktop OAuth, ChatGPT account identity and cookies at the bridge
-            // boundary; the Host allowlist repeats this check before sending.
-            headers: filterRealtimeCallHeaders(Object.fromEntries(new Headers(options.headers)))
-          })
-        );
-        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 });
-          options.signal.throwIfAborted();
-        }
-        const response = new Response(result.status === 204 ? null : result.body, {
-          status: result.status,
-          headers: result.headers
-        });
-        if (!response.ok) throw await responseError(response, url2);
-        return response;
-      } catch (error51) {
-        cancel();
-        throw error51;
-      } finally {
-        options.signal?.removeEventListener("abort", cancel);
-      }
-    };
-    client.fetch = wrapped;
-    return () => {
-      if (client.fetch === wrapped) client.fetch = original;
-    };
-  }
-  function installClientOwnedVoiceHook(options = {}) {
-    const target = options.target ?? globalThis;
-    const existing = target[HOOK_GLOBAL];
-    if (existing) return existing;
-    const config2 = readCpaLiveVoiceHookConfig(target);
-    if (!config2) return { status: "disabled", dispose() {
-    } };
-    if (config2.desktopVersion !== void 0 && config2.desktopVersion !== CLIENT_OWNED_VOICE_VERSION)
-      return { status: "unsupported", dispose() {
-      } };
-    const importModule = options.importModule ?? ((url2) => import(url2));
-    let disposed = false;
-    let timer;
-    let restore;
-    const started = Date.now();
-    const handle = {
-      status: "pending",
-      dispose() {
-        disposed = true;
-        if (timer !== void 0) target.clearTimeout(timer);
-        restore?.();
-        if (target[HOOK_GLOBAL] === handle) Reflect.deleteProperty(target, HOOK_GLOBAL);
-      }
-    };
-    target[HOOK_GLOBAL] = handle;
-    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)) {
-        try {
-          const module = await importModule(`app://-/assets/${CLIENT_OWNED_VOICE_SHARED_ASSET}`);
-          if (disposed) return;
-          if (typeof module.frt !== "function") throw new Error();
-          module.frt();
-          const fetchClass = module.urt;
-          const bridgeClass = module.mPt;
-          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")
-            throw new Error();
-          restore = wrapClientOwnedVoiceFetch(
-            client,
-            bridge,
-            () => cpaLiveVoicePreferenceAllowsInstall(target),
-            module.grt,
-            () => chatLiveVoicePreferenceAllowsOverride(target),
-            () => isWorkComposerSurface(target),
-            () => isExternalHarnessComposer(target)
-          );
-          handle.status = "active";
-        } catch {
-          handle.status = "unsupported";
-        }
-        return;
-      }
-      if (Date.now() - started >= 6e4) {
-        handle.status = "unsupported";
-        return;
-      }
-      timer = target.setTimeout(() => void attempt(), 250);
-    };
-    void attempt();
-    return handle;
-  }
-
-  // src/renderer-native-chat-voice-state.ts
-  function observeNativeChatVoiceState(scope, initial) {
-    const store = Reflect.apply(initial.ejn, void 0, [
-      scope
-    ]);
-    let last = "";
-    const report = () => {
-      const state = store.getState();
-      const connection = state.server?.connectionState;
-      const microphone = initial.sUn == null ? void 0 : scope.get(initial.sUn);
-      const detail = {
-        active: state.isVoiceModeActive === true,
-        connectedOnce: state.hasConnectedOnce === true,
-        sessionStarted: state.hasVoiceSessionStarted === true,
-        serverConversationReady: typeof state.earlyServerThreadId === "string" && /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i.test(state.earlyServerThreadId),
-        connection: typeof connection === "string" && ["disconnected", "connecting", "connected", "reconnecting", "signalReconnecting"].includes(
-          connection
-        ) ? connection : "unknown",
-        microphone: typeof microphone === "string" && ["unknown", "pending", "granted", "denied"].includes(microphone) ? microphone : "unknown"
-      };
-      const next = JSON.stringify(detail);
-      if (next === last) return;
-      last = next;
-      chatVoiceDebug("native-chat-state", detail);
-    };
-    const unsubscribe = store.subscribe(report);
-    report();
-    return unsubscribe;
-  }
-
-  // src/renderer-native-chat-voice-selection.ts
-  var UUID = /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i;
-  function nativeChatVoiceDraftSelection(binding, initial, shared, origin, signal) {
-    const draft = binding.props.conversationId;
-    const navigate = initial.uIr;
-    const conversationPath = shared.xat;
-    if (binding.backendConversationId !== void 0 || !draft.startsWith("local-chatgpt:") || !UUID.test(draft.slice("local-chatgpt:".length)) || origin == null || initial.FFr == null || initial.kZn == null || initial.SZn == null || typeof navigate !== "function" || typeof conversationPath !== "function")
-      return () => {
-      };
-    const store = Reflect.apply(initial.ejn, void 0, [
-      binding.scope
-    ]);
-    let session = store.getState().voiceSessionId;
-    let activeSeen = store.getState().isVoiceModeActive;
-    let finished = false;
-    return () => {
-      if (finished) return;
-      try {
-        const state = store.getState();
-        if (signal.aborted || binding.scope.get(initial.FFr) !== origin || activeSeen && (!state.isVoiceModeActive || state.voiceSessionId !== session)) {
-          finished = true;
-          return;
-        }
-        if (!state.isVoiceModeActive) return;
-        if (!activeSeen) {
-          session = state.voiceSessionId;
-          activeSeen = true;
-        }
-        if (state.isWorkMode !== false || state.conversationId !== draft) {
-          finished = true;
-          return;
-        }
-        if (!state.hasVoiceSessionStarted || state.server.connectionState !== "connected") return;
-        const backend = binding.scope.get(initial.pZn, draft);
-        if (typeof backend !== "string" || !UUID.test(backend)) return;
-        const mapping = binding.scope.get(initial.kZn, draft);
-        const currentNode = binding.scope.get(initial.SZn, draft);
-        if (mapping == null || typeof mapping !== "object" || typeof currentNode !== "string" || !mapping[currentNode]?.message)
-          return;
-        finished = true;
-        const path = Reflect.apply(conversationPath, void 0, [draft]);
-        const accepted = Reflect.apply(navigate, void 0, [binding.scope, path]);
-        void Promise.resolve(accepted).then(
-          (result) => chatVoiceDebug(
-            result === false ? "native-chat-selection-declined" : "native-chat-draft-selection-requested"
-          ),
-          () => chatVoiceDebug("native-chat-selection-failed")
-        );
-      } catch {
-        finished = true;
-        chatVoiceDebug("native-chat-selection-failed");
-      }
-    };
-  }
-
-  // src/renderer-native-chat-voice.ts
-  var HOOK_GLOBAL2 = "__codexhostNativeChatVoiceV1";
-  var START_ASSET = "start-voice-954090654801.js";
-  var PREWARM_ASSET = "voice-prewarm-fb2c91219553.js";
-  var BUTTON = "data-codexhost-chat-voice-start";
-  var CONVERSATION_UUID = /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i;
-  var record2 = (value) => value !== null && typeof value === "object";
-  function scopeRefs(owner, definition) {
-    const scopes = /* @__PURE__ */ new Map();
-    let hook = owner.memoizedState;
-    const seen = /* @__PURE__ */ new Set();
-    while (record2(hook) && seen.size < 4096 && !seen.has(hook)) {
-      seen.add(hook);
-      const state = hook.memoizedState;
-      const scope = record2(state) ? state.current : void 0;
-      if (record2(scope) && scope.scope === definition && typeof scope.get === "function" && typeof scope.set === "function" && scope.chain instanceof Map && scope.chain.get(definition.id) === scope.node)
-        scopes.set(scope.node, scope);
-      hook = hook.next;
-    }
-    return hook == null ? scopes : /* @__PURE__ */ new Map();
-  }
-  function detectNativeChatVoiceBinding(composer, native) {
-    const key = Object.getOwnPropertyNames(composer).find((key2) => key2.startsWith("__reactFiber$"));
-    if (!key) return;
-    const ancestors = committedReactAncestors(Object.getOwnPropertyDescriptor(composer, key)?.value);
-    for (const owner of ancestors) {
-      const props = owner.memoizedProps;
-      if (!record2(props) || typeof props.isWorkConversation !== "boolean" || typeof props.isTemporaryChat !== "boolean" || typeof props.conversationId !== "string")
-        continue;
-      if (props.isWorkConversation || props.isTemporaryChat || props.shouldBlockExternalEgress !== false || props.readOnly === true || !record2(props.composerSelectionContext) || props.composerSelectionContext.conversationId !== props.conversationId)
-        return;
-      const scopes = scopeRefs(owner, native.scopeDefinition);
-      if (scopes.size !== 1) return;
-      const scope = [...scopes.values()][0];
-      if (!scope) return;
-      const backendId = scope.get(native.backendConversationId, props.conversationId);
-      const hasBackendId = typeof backendId === "string" && CONVERSATION_UUID.test(backendId);
-      const isDraft = backendId == null && props.conversationId.startsWith("local-chatgpt:") && CONVERSATION_UUID.test(props.conversationId.slice("local-chatgpt:".length));
-      if (!hasBackendId && !isDraft) return;
-      const draftScopes = /* @__PURE__ */ new Map();
-      if (isDraft) {
-        for (const fiber of ancestors)
-          for (const [node, ref] of scopeRefs(fiber, native.composerScopeDefinition))
-            if (ref.chain.get(native.scopeDefinition.id) === scope.node) draftScopes.set(node, ref);
+    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")
+        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);
       }
-      const contexts = /* @__PURE__ */ new Set();
-      let composerContext;
-      for (const fiber of ancestors) {
-        let dependency = record2(fiber.dependencies) ? fiber.dependencies.firstContext : void 0;
-        const seenDependencies = /* @__PURE__ */ new Set();
-        while (record2(dependency) && seenDependencies.size < 4096 && !seenDependencies.has(dependency)) {
-          seenDependencies.add(dependency);
-          const context = dependency.context;
-          const chain = dependency.memoizedValue;
-          if (record2(context) && context.displayName === native.scopeDefinition.__scopeBrand && chain instanceof Map && chain.get(native.scopeDefinition.id) === scope.node)
-            contexts.add(context);
-          if (!composerContext && record2(context) && context.displayName === native.composerScopeDefinition.__scopeBrand && chain instanceof Map && chain.get(native.scopeDefinition.id) === scope.node) {
-            const node = chain.get(native.composerScopeDefinition.id);
-            if (record2(node) && record2(node.value) && (node.value.kind === "chatgpt" && record2(node.value.chatGptSelectionContext) && node.value.chatGptSelectionContext.conversationId === props.conversationId || isDraft && node.value.kind === "new" && native.draftConversationId != null && draftScopes.get(node)?.get(native.draftConversationId) === props.conversationId))
-              composerContext = { context, chain };
-            else return;
-          }
-          dependency = dependency.next;
+      if (typeof options.body !== "string") throw new Error("Unsupported native voice call request");
+      options.signal?.throwIfAborted();
+      const requestId2 = crypto.randomUUID();
+      let cancelled = false;
+      const cancel = () => {
+        if (cancelled) return;
+        cancelled = true;
+        void requestVoiceHost(bridge, { operation: "cancel", requestId: requestId2 }).catch(() => void 0);
+      };
+      options.signal?.addEventListener("abort", cancel, { once: true });
+      try {
+        const result = realtimeCallResponseSchema.parse(
+          await requestVoiceHost(bridge, {
+            operation: "create",
+            requestId: requestId2,
+            body: options.body,
+            // Drop Desktop OAuth, ChatGPT account identity and cookies at the bridge
+            // boundary; the Host allowlist repeats this check before sending.
+            headers: filterRealtimeCallHeaders(Object.fromEntries(new Headers(options.headers)))
+          })
+        );
+        if (options.signal?.aborted) {
+          const callId = realtimeCallIdFromLocation(result.headers.location ?? "");
+          if (result.status >= 200 && result.status < 300 && isRealtimeCallId(callId))
+            await requestVoiceHost(bridge, { operation: "hangup", callId });
+          options.signal.throwIfAborted();
         }
+        const response = new Response(result.status === 204 ? null : result.body, {
+          status: result.status,
+          headers: result.headers
+        });
+        if (!response.ok) throw await responseError(response, url2);
+        return response;
+      } catch (error51) {
+        cancel();
+        throw error51;
+      } finally {
+        options.signal?.removeEventListener("abort", cancel);
       }
-      if (contexts.size !== 1 || !composerContext) return;
-      return {
-        composer,
-        props,
-        scope,
-        context: [...contexts][0],
-        composerContext,
-        backendConversationId: hasBackendId ? backendId : void 0
-      };
-    }
-  }
-  function startNativeChatVoiceForRequest(request, target = globalThis) {
-    if (!record2(request) || request.productExperience !== "chat" || !nativeChatVoicePreferenceAllowsStart(target))
-      return;
-    const hook = target[HOOK_GLOBAL2];
-    if (!hook || hook.status === "disabled") return;
-    return hook.start();
+    };
+    client.fetch = wrapped;
+    return () => {
+      if (client.fetch === wrapped) client.fetch = original;
+    };
   }
-  function installNativeChatVoiceHook(options = {}) {
+  function installClientOwnedVoiceHook(options = {}) {
     const target = options.target ?? globalThis;
     const existing = target[HOOK_GLOBAL2];
     if (existing) return existing;
     const config2 = readCpaLiveVoiceHookConfig(target);
-    const unavailable = (status) => ({
-      status,
-      dispose() {
-      },
-      start: async () => {
-        throw new Error("Native Chat voice is unavailable");
-      }
-    });
-    if (!config2) return unavailable("disabled");
-    if (config2.desktopVersion !== void 0 && config2.desktopVersion !== CLIENT_OWNED_VOICE_VERSION)
-      return unavailable("unsupported");
-    const doc = target.document;
-    if (!doc) return unavailable("unsupported");
+    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));
     let disposed = false;
     let timer;
-    let modules;
-    let boundScope;
-    let mounted;
-    let button2;
-    const overlayButtons = /* @__PURE__ */ new Map();
-    let controller;
-    let starting = false;
-    let selectDraft;
-    let renderFailed = false;
+    let restore;
     const started = Date.now();
-    const removeButton = () => {
-      button2?.remove();
-      button2 = void 0;
-    };
-    const release = () => {
-      selectDraft = void 0;
-      controller?.abort();
-      controller = void 0;
-      removeButton();
-      for (const [control, [display, priority]] of overlayButtons)
-        if (control.style.getPropertyValue("display") === "none" && control.style.getPropertyPriority("display") === "important")
-          control.style.setProperty("display", display, priority);
-      overlayButtons.clear();
-      mounted?.dispose();
-      mounted = void 0;
-      boundScope = void 0;
-    };
-    const findBinding = () => {
-      if (!modules || !nativeChatVoicePreferenceAllowsStart(target)) return;
-      const forms = [...doc.querySelectorAll("[data-chatgpt-composer]")].filter(
-        (form2) => form2.getBoundingClientRect().width > 0 && !form2.closest("[hidden], [inert]")
-      );
-      if (forms.length !== 1) return;
-      const form = forms[0];
-      if (!form) return;
-      return detectNativeChatVoiceBinding(form, {
-        scopeDefinition: modules.shared.Cot,
-        backendConversationId: modules.initial.pZn,
-        draftConversationId: modules.initial.lXt,
-        composerScopeDefinition: modules.initial.xAt.scope
-      });
-    };
     const handle = {
-      get activeCall() {
-        if (starting) return true;
-        if (!boundScope || !modules || typeof modules.initial.ejn !== "function") return false;
-        try {
-          return modules.initial.ejn(boundScope).getState().isVoiceModeActive;
-        } catch {
-          return false;
-        }
-      },
       status: "pending",
-      async start() {
-        if (disposed || starting) return;
-        const current = findBinding();
-        if (!current || !modules || current.scope.node !== mounted?.node)
-          throw new Error("Select a ChatGPT conversation to start Chat voice");
-        starting = true;
-        controller = new AbortController();
-        const signal = controller.signal;
-        let origin;
-        try {
-          if (modules.initial.FFr != null) origin = current.scope.get(modules.initial.FFr);
-        } catch {
-          chatVoiceDebug("native-chat-selection-failed");
-        }
-        selectDraft = void 0;
-        chatVoiceDebug("native-chat-start", {
-          hasConversationId: current.backendConversationId !== void 0
-        });
-        try {
-          await Reflect.apply(modules.start.n, void 0, [
-            current.scope,
-            current.props,
-            { event_source: "composer" },
-            signal
-          ]);
-          chatVoiceDebug("native-chat-start-returned");
-          try {
-            selectDraft = nativeChatVoiceDraftSelection(
-              current,
-              modules.initial,
-              modules.shared,
-              origin,
-              signal
-            );
-            selectDraft();
-          } catch {
-            chatVoiceDebug("native-chat-selection-failed");
-          }
-        } catch {
-          chatVoiceDebug("native-chat-start-failed");
-          throw new Error("Native Chat voice could not start");
-        } finally {
-          starting = false;
-        }
-      },
       dispose() {
         disposed = true;
         if (timer !== void 0) target.clearTimeout(timer);
-        release();
+        restore?.();
         if (target[HOOK_GLOBAL2] === handle) Reflect.deleteProperty(target, HOOK_GLOBAL2);
       }
     };
     target[HOOK_GLOBAL2] = handle;
-    const refresh = async () => {
+    const attempt = async () => {
       if (disposed) return;
-      try {
-        if (renderFailed) throw new Error();
-        if (!modules) {
-          const names = loadedAssetNames(doc, target.performance);
-          if (!auditedAppInitialAssetPresent(names, CLIENT_OWNED_VOICE_INITIAL_ASSET) || !auditedAppInitialAssetPresent(names, CLIENT_OWNED_VOICE_SHARED_ASSET)) {
-            if (Date.now() - started >= 6e4) {
-              handle.status = "unsupported";
-              return;
-            }
-            return;
-          }
-          const [shared, initial, start, prewarm] = await Promise.all(
-            [
-              CLIENT_OWNED_VOICE_SHARED_ASSET,
-              CLIENT_OWNED_VOICE_INITIAL_ASSET,
-              START_ASSET,
-              PREWARM_ASSET
-            ].map((asset) => importModule(`app://-/assets/${asset}`))
-          );
+      const names = loadedAssetNames(target.document, target.performance);
+      const assets = selectVoiceAssets(CLIENT_OWNED_VOICE_ASSETS, names, config2.desktopVersion);
+      if (assets) {
+        try {
+          const module = await importModule(`app://-/assets/${assets.shared}`);
           if (disposed) return;
-          if (!shared || !initial || !start || !prewarm || typeof start.t !== "function" || typeof start.n !== "function" || typeof initial.jw !== "function" || typeof initial.ejn !== "function" || typeof shared.yzt !== "function" || typeof shared.vMt !== "function" || typeof prewarm.VoiceInstantConnectCacheController !== "function")
-            throw new Error();
-          initial.jw();
-          start.t();
-          if (!record2(shared.Cot) || !initial.pZn || !initial.lXt || !initial.Aw || !record2(initial.xAt) || !record2(initial.xAt.scope))
+          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[SHARED_RESPONSE_ERROR] !== "function")
             throw new Error();
-          modules = { shared, initial, start, prewarm };
-        }
-        const current = findBinding();
-        selectDraft?.();
-        if (!current) {
-          if (handle.activeCall) return;
-          release();
-          handle.status = "pending";
-          return;
-        }
-        if (mounted && current.scope.node !== mounted.node) release();
-        boundScope = current.scope;
-        if (!mounted) {
-          const { scope } = current;
-          const initial = modules.initial;
-          const previous = scope.get(initial.Aw);
-          const container = doc.createElement("div");
-          container.setAttribute("data-codexhost-chat-voice-prewarm", "");
-          doc.body.append(container);
-          const react = Reflect.apply(modules.shared.yzt, void 0, []);
-          const reactDom = Reflect.apply(modules.shared.vMt, void 0, []);
-          const root = reactDom.createRoot(container, {
-            onUncaughtError() {
-              renderFailed = true;
-            }
-          });
-          const stopObserving = observeNativeChatVoiceState(scope, initial);
-          let appChain;
-          let composerChain;
-          mounted = {
-            node: scope.node,
-            render(next) {
-              if (appChain === next.scope.chain && composerChain === next.composerContext.chain)
-                return;
-              appChain = next.scope.chain;
-              composerChain = next.composerContext.chain;
-              root.render(
-                react.createElement(
-                  next.context,
-                  { value: appChain },
-                  react.createElement(
-                    next.composerContext.context,
-                    { value: composerChain },
-                    react.createElement(modules?.prewarm.VoiceInstantConnectCacheController, null)
-                  )
-                )
-              );
-            },
-            dispose() {
-              stopObserving();
-              root.unmount();
-              container.remove();
-              if (scope.get(initial.Aw) === true) scope.set(initial.Aw, previous);
-              chatVoiceDebug("native-chat-unbound");
-            }
-          };
-          scope.set(initial.Aw, true);
-          chatVoiceDebug("native-chat-bound", {
-            hasConversationId: current.backendConversationId !== void 0
-          });
-        }
-        mounted.render(current);
-        if (!button2 || !current.composer.contains(button2)) {
-          removeButton();
-          const dictate = current.composer.querySelector(
-            'button[aria-label="Dictate"]'
+          restore = wrapClientOwnedVoiceFetch(
+            client,
+            bridge,
+            () => cpaLiveVoicePreferenceAllowsInstall(target),
+            module[SHARED_RESPONSE_ERROR],
+            () => chatLiveVoicePreferenceAllowsOverride(target),
+            () => isWorkComposerSurface(target),
+            () => isExternalHarnessComposer(target)
           );
-          if (dictate?.parentElement) {
-            button2 = doc.createElement("button");
-            button2.type = "button";
-            button2.className = dictate.className;
-            button2.setAttribute(BUTTON, "");
-            button2.setAttribute("aria-label", "Start Voice");
-            button2.title = "Start Voice";
-            button2.innerHTML = '<svg width="20" height="20" viewBox="0 0 20 20" fill="none" aria-hidden="true"><path d="M3 8v4m4-7v10m6-12v14m4-9v4" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>';
-            button2.addEventListener("click", () => {
-              void handle.start().catch(() => {
-                if (button2) button2.title = "Chat voice could not start. Try again.";
-              });
-            });
-            dictate.parentElement.append(button2);
-          }
+          handle.status = "active";
+        } catch {
+          handle.status = "unsupported";
         }
-        if (button2)
-          for (const control of current.composer.querySelectorAll(
-            'button[aria-label="Start new voice chat"], button[aria-label="Start voice chat"]'
-          )) {
-            if (!overlayButtons.has(control))
-              overlayButtons.set(control, [
-                control.style.getPropertyValue("display"),
-                control.style.getPropertyPriority("display")
-              ]);
-            control.style.setProperty("display", "none", "important");
-          }
-        if (button2)
-          button2.disabled = starting || current.props.isStreaming === true || modules.initial.ejn instanceof Function && modules.initial.ejn(current.scope).getState().isVoiceModeActive;
-        handle.status = "active";
-      } catch {
-        release();
+        return;
+      }
+      if (Date.now() - started >= 6e4) {
         handle.status = "unsupported";
-        chatVoiceDebug("native-chat-binding-failed");
         return;
-      } finally {
-        if (!disposed && handle.status !== "unsupported")
-          timer = target.setTimeout(() => void refresh(), 500);
       }
+      timer = target.setTimeout(() => void attempt(), 250);
     };
-    void refresh();
+    void attempt();
     return handle;
   }
 
@@ -17439,13 +17613,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (busy || disposed) return;
       busy = true;
       try {
+        const activeCall = desktopVoiceCallActive(owner);
         let state = voiceSettingsStateSchema.parse(
           await request(VOICE_SETTINGS_METHOD, {
             operation: "get",
-            runtime: { id, revision, activeCall: desktopVoiceCallActive(owner) }
+            runtime: { id, revision, activeCall }
           })
         );
         if (disposed) return;
+        const ready = state.gatewayReady ?? await request(VOICE_GATEWAY_STATUS_METHOD, {});
+        if (disposed) return;
+        applyVoiceGatewayReadiness(owner, ready === true);
         if (!state.initialized)
           state = voiceSettingsStateSchema.parse(
             await request(VOICE_SETTINGS_METHOD, {
@@ -17453,7 +17631,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               routes: legacyVoiceRoutes(owner)
             })
           );
-        if (!disposed && !desktopVoiceCallActive(owner)) {
+        if (!disposed && !activeCall && state.revision !== revision) {
           applySharedVoiceRoutes(owner, state.settings);
           revision = state.revision;
         }
@@ -17466,6 +17644,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const timer = owner.setInterval(() => void refresh(), intervalMs);
     return () => {
       disposed = true;
+      applyVoiceGatewayReadiness(owner, false);
       owner.clearInterval(timer);
     };
   }
@@ -18520,6 +18699,242 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return section;
   }
 
+  // src/settings/preference-ui.ts
+  var nextPreferenceId = 0;
+  function preferenceId(prefix) {
+    nextPreferenceId += 1;
+    return `codexhost-${prefix}-${nextPreferenceId}`;
+  }
+  function createPreferenceGroup(document2, title) {
+    const group = document2.createElement("section");
+    group.className = "mt-7 first-of-type:mt-0";
+    const header = document2.createElement("div");
+    header.className = "mb-2 flex min-h-6 items-center gap-2 px-1";
+    const heading = document2.createElement("h3");
+    heading.id = preferenceId("preference-group");
+    heading.className = "m-0 text-[13px] leading-5 font-semibold text-settings-text";
+    heading.textContent = title;
+    header.append(heading);
+    const card = document2.createElement("div");
+    card.className = "rounded-[10px] border border-settings-border bg-settings-panel";
+    group.setAttribute("aria-labelledby", heading.id);
+    group.append(header, card);
+    return { group, header, card };
+  }
+  function createPreferenceItem(document2, input) {
+    const item = document2.createElement("div");
+    item.className = "flex min-h-[60px] items-center justify-between gap-6 border-t border-settings-divider px-4 py-3 first:border-t-0";
+    const copy = document2.createElement("div");
+    copy.className = "flex min-w-0 flex-col gap-0.5";
+    const heading = document2.createElement("div");
+    heading.className = "flex items-center gap-1.5";
+    const title = document2.createElement("label");
+    title.htmlFor = input.controlId;
+    title.className = "cursor-pointer text-[13px] leading-5 font-medium text-settings-text";
+    title.textContent = input.title;
+    heading.append(title);
+    if (input.help) heading.append(createHelpTooltip(document2, input.help.label, input.help.lines));
+    const description = document2.createElement("div");
+    description.id = preferenceId("preference-description");
+    description.className = "text-xs leading-[18px] text-settings-muted data-[invalid=true]:text-settings-danger";
+    description.textContent = input.description;
+    copy.append(heading, description);
+    item.append(copy);
+    return { item, description };
+  }
+  function createHelpTooltip(document2, label, lines) {
+    const wrapper = document2.createElement("span");
+    wrapper.className = "group relative inline-flex";
+    const button2 = document2.createElement("button");
+    button2.type = "button";
+    button2.className = "inline-flex size-4 cursor-help items-center justify-center rounded-full border-0 bg-transparent p-0 text-settings-subtle transition-colors hover:text-settings-text focus-visible:text-settings-text focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-settings-focus";
+    button2.setAttribute("aria-label", label);
+    button2.append(createRendererSettingsIcon("help", 14));
+    const tooltip = document2.createElement("div");
+    tooltip.id = preferenceId("preference-tooltip");
+    tooltip.setAttribute("role", "tooltip");
+    tooltip.className = "pointer-events-none invisible absolute top-full left-0 z-20 mt-2 w-80 rounded-lg border border-settings-border bg-settings-panel px-3 py-2.5 text-xs leading-[18px] font-normal text-settings-text opacity-0 shadow-[0_10px_30px_rgb(0_0_0/0.22)] transition-opacity duration-150 group-hover:visible group-hover:opacity-100 group-focus-within:visible group-focus-within:opacity-100";
+    const list = document2.createElement("ul");
+    list.className = "m-0 grid list-disc gap-1 pl-4 marker:text-settings-subtle";
+    for (const line of lines) {
+      const item = document2.createElement("li");
+      item.textContent = line;
+      list.append(item);
+    }
+    tooltip.append(list);
+    button2.setAttribute("aria-describedby", tooltip.id);
+    button2.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") button2.blur();
+    });
+    wrapper.append(button2, tooltip);
+    return wrapper;
+  }
+  function createPreferenceSwitch(document2, id, describedBy) {
+    const input = document2.createElement("input");
+    input.type = "checkbox";
+    input.id = id;
+    input.setAttribute("role", "switch");
+    input.setAttribute("aria-describedby", describedBy);
+    input.className = "relative m-0 h-5 w-9 shrink-0 cursor-pointer appearance-none rounded-full bg-settings-surface-hover ring-1 ring-settings-border transition-colors ring-inset before:absolute before:top-0.5 before:left-0.5 before:size-4 before:rounded-full before:bg-white before:shadow-[0_1px_2px_rgb(0_0_0/0.3)] before:transition-transform checked:bg-settings-focus checked:ring-transparent checked:before:translate-x-4 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-settings-focus";
+    return input;
+  }
+  function createNumberField(document2, input) {
+    const field = document2.createElement("div");
+    field.className = "flex h-8 shrink-0 items-center gap-1.5 rounded-md border border-settings-border bg-settings-surface px-2.5 transition-colors focus-within:border-settings-focus data-[invalid=true]:border-settings-danger";
+    const control = document2.createElement("input");
+    control.type = "number";
+    control.id = input.id;
+    control.min = String(input.min);
+    control.max = String(input.max);
+    control.step = "1";
+    control.setAttribute("aria-describedby", input.describedBy);
+    control.className = "w-14 border-0 bg-transparent p-0 text-right text-[13px] leading-5 text-settings-text tabular-nums outline-none";
+    const unit = document2.createElement("span");
+    unit.className = "text-xs text-settings-muted";
+    unit.setAttribute("aria-hidden", "true");
+    unit.textContent = input.unit;
+    field.append(control, unit);
+    return { field, control };
+  }
+
+  // src/settings/grok-computer-use-controls.ts
+  function createGrokComputerUseControls(document2, messages, settings) {
+    const section = document2.createElement("section");
+    section.className = "settings-grok-computer-use";
+    section.dataset.grokComputerUse = "true";
+    const header = document2.createElement("div");
+    header.className = "settings-grok-computer-use__header";
+    const copy = document2.createElement("div");
+    copy.className = "settings-grok-computer-use__copy";
+    const title = document2.createElement("h3");
+    title.className = "settings-grok-computer-use__title";
+    title.id = "grok-computer-use-title";
+    title.textContent = messages.grokComputerUseTitle;
+    const description = document2.createElement("p");
+    description.className = "settings-grok-computer-use__description";
+    description.id = "grok-computer-use-description";
+    description.textContent = messages.grokComputerUseDescription;
+    copy.append(title, description);
+    const input = createPreferenceSwitch(
+      document2,
+      "grok-computer-use-enabled",
+      "grok-computer-use-description grok-computer-use-help grok-computer-use-status"
+    );
+    input.setAttribute("aria-labelledby", title.id);
+    input.setAttribute("aria-label", messages.grokComputerUseLabel);
+    header.append(copy, input);
+    const help = document2.createElement("p");
+    help.className = "settings-grok-computer-use__help";
+    help.id = "grok-computer-use-help";
+    help.textContent = messages.grokComputerUseHelp;
+    const status = document2.createElement("p");
+    status.className = "settings-grok-computer-use__status";
+    status.id = "grok-computer-use-status";
+    status.setAttribute("role", "status");
+    status.setAttribute("aria-live", "polite");
+    const browserHeader = document2.createElement("div");
+    browserHeader.className = "settings-grok-computer-use__header settings-grok-computer-use__browser";
+    const browserCopy = document2.createElement("div");
+    browserCopy.className = "settings-grok-computer-use__copy";
+    const browserTitle = document2.createElement("h3");
+    browserTitle.className = "settings-grok-computer-use__title";
+    browserTitle.id = "grok-browser-title";
+    browserTitle.textContent = messages.grokBrowserTitle;
+    const browserDescription = document2.createElement("p");
+    browserDescription.className = "settings-grok-computer-use__description";
+    browserDescription.id = "grok-browser-description";
+    browserDescription.textContent = messages.grokBrowserDescription;
+    browserCopy.append(browserTitle, browserDescription);
+    const browserInput = createPreferenceSwitch(
+      document2,
+      "grok-browser-enabled",
+      "grok-browser-description grok-browser-help grok-browser-status"
+    );
+    browserInput.setAttribute("aria-labelledby", browserTitle.id);
+    browserInput.setAttribute("aria-label", messages.grokBrowserLabel);
+    browserHeader.append(browserCopy, browserInput);
+    const browserHelp = document2.createElement("p");
+    browserHelp.className = "settings-grok-computer-use__help";
+    browserHelp.id = "grok-browser-help";
+    browserHelp.textContent = messages.grokBrowserHelp;
+    const browserStatus = document2.createElement("p");
+    browserStatus.className = "settings-grok-computer-use__status";
+    browserStatus.id = "grok-browser-status";
+    browserStatus.setAttribute("role", "status");
+    browserStatus.setAttribute("aria-live", "polite");
+    section.append(header, help, status, browserHeader, browserHelp, browserStatus);
+    let busy = true;
+    let loaded = false;
+    let last;
+    const show = (value) => {
+      last = value;
+      input.checked = value.enabled;
+      input.disabled = busy || !loaded || !value.available && !value.enabled;
+      const browserOn = value.browser === true;
+      const browserFiles = value.browserFilesPresent === true;
+      browserInput.checked = browserOn;
+      browserInput.disabled = busy || !loaded || !browserFiles && !browserOn;
+      if (!browserFiles) {
+        browserStatus.dataset.state = "unavailable";
+        browserStatus.textContent = value.browserUnavailableReason ?? messages.grokBrowserUnavailable;
+      } else if (value.browserAvailable !== true) {
+        browserStatus.dataset.state = browserOn ? "unavailable" : "off";
+        browserStatus.textContent = browserOn ? value.browserUnavailableReason ?? messages.grokBrowserBlocked : messages.grokBrowserOff;
+      } else {
+        browserStatus.dataset.state = browserOn ? "on" : "off";
+        browserStatus.textContent = browserOn ? messages.grokBrowserOn : messages.grokBrowserOff;
+      }
+      if (value.applyFailed) {
+        status.dataset.state = "unavailable";
+        status.textContent = value.applyError ?? messages.grokComputerUseApplyFailed;
+        return;
+      }
+      if (!value.available) {
+        status.dataset.state = "unavailable";
+        status.textContent = value.unavailableReason ?? messages.grokComputerUseUnavailable;
+        return;
+      }
+      status.dataset.state = value.enabled ? "on" : "off";
+      status.textContent = value.enabled ? messages.grokComputerUseOn : messages.grokComputerUseOff;
+    };
+    const save = (update, target) => {
+      if (busy || !loaded) return;
+      busy = true;
+      input.disabled = true;
+      browserInput.disabled = true;
+      target.textContent = messages.grokComputerUseSaving;
+      void settings.set(update).then((value) => {
+        busy = false;
+        show(value);
+      }).catch(() => {
+        busy = false;
+        if (last) show(last);
+        else {
+          input.disabled = false;
+          browserInput.disabled = false;
+        }
+        target.textContent = messages.grokComputerUseSaveError;
+      });
+    };
+    input.addEventListener("change", () => save({ enabled: input.checked }, status));
+    browserInput.addEventListener(
+      "change",
+      () => save({ browser: browserInput.checked }, browserStatus)
+    );
+    status.textContent = messages.grokComputerUseLoading;
+    browserStatus.textContent = messages.grokBrowserOff;
+    void settings.get().then((value) => {
+      loaded = true;
+      busy = false;
+      show(value);
+    }).catch(() => {
+      busy = false;
+      status.textContent = messages.grokComputerUseLoadError;
+      browserStatus.textContent = messages.grokComputerUseLoadError;
+    });
+    return section;
+  }
+
   // src/settings/harness-installation-guides.ts
   function harnessHasInstallCommands(plugin) {
     return (plugin?.installation?.commands.length ?? 0) > 0;
@@ -18702,7 +19117,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
 
   // src/settings/harness-version-panel.ts
-  function createHarnessVersionPanel(document2, messages, signal, agent, client) {
+  function createHarnessVersionPanel(document2, messages, signal, agent, client, onChange = () => void 0) {
     const panel = document2.createElement("section");
     panel.className = "settings-harness-version";
     panel.dataset.harnessVersion = agent;
@@ -18728,6 +19143,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     panel.append(heading, versions, status, actions, note);
     let state;
     let busy = false;
+    let updating = false;
     let unsupported = false;
     const render = () => {
       current.textContent = `${messages.harnessVersionCurrent}: ${state?.currentVersion ?? "\u2014"}`;
@@ -18741,6 +19157,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (busy || unsupported || signal.aborted) return;
       if (action === "update" && (!state?.canUpdate || !state.updateAvailable)) return;
       busy = true;
+      updating = action === "update";
+      onChange();
       status.textContent = action === "check" ? messages.harnessVersionChecking : messages.harnessVersionUpdating;
       render();
       try {
@@ -18755,7 +19173,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         if (state) state = { ...state, canUpdate: false };
       } finally {
         busy = false;
-        if (!signal.aborted) render();
+        updating = false;
+        if (!signal.aborted) {
+          render();
+          onChange();
+        }
       }
     };
     update.addEventListener("click", () => void run("update"));
@@ -18785,7 +19207,43 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     } else {
       void run("check");
     }
-    return panel;
+    return {
+      element: panel,
+      get state() {
+        return state;
+      },
+      get updating() {
+        return updating;
+      },
+      update: () => void run("update")
+    };
+  }
+
+  // src/settings/connection-versions.ts
+  function createConnectionVersions(document2, messages, signal, diagnostics, onChange) {
+    const panels = /* @__PURE__ */ new Map();
+    const installation = diagnostics?.installation?.bind(diagnostics);
+    return {
+      get(hostId2, agent) {
+        if (!installation || signal.aborted) return void 0;
+        const key = JSON.stringify([hostId2, agent]);
+        let panel = panels.get(key);
+        if (!panel) {
+          panel = createHarnessVersionPanel(
+            document2,
+            messages,
+            signal,
+            agent,
+            {
+              run: (action) => installation(hostId2, agent, action)
+            },
+            onChange
+          );
+          panels.set(key, panel);
+        }
+        return panel;
+      }
+    };
   }
 
   // src/settings/connections-page.ts
@@ -18953,6 +19411,14 @@ ${error51.stderrTail}`] : []
     status.dataset.connectionTone = connectionStatusTone(item.availability, item.error !== null);
     status.setAttribute("role", "cell");
     status.textContent = item.error?.code === "authenticationRequired" ? messages.connectionLoginRequired : item.error?.code === "configurationRequired" ? messages.connectionConfigurationRequired : connectionStatusLabel(item.availability, messages, item.error !== null);
+    const version2 = item.version;
+    if (version2?.state?.updateAvailable && !version2.updating) {
+      const available = document2.createElement("span");
+      available.className = "settings-connection-version-available";
+      available.textContent = `${messages.harnessVersionAvailable}: ${harnessVersionLabel(version2.state, messages.harnessVersion)}`;
+      available.title = `${messages.harnessVersionCurrent}: ${version2.state.currentVersion ?? "\u2014"}`;
+      status.append(available);
+    }
     const action = document2.createElement("div");
     action.className = "settings-connection-row__action";
     action.setAttribute("role", "cell");
@@ -18982,6 +19448,23 @@ ${error51.stderrTail}`] : []
       });
       action.append(viewError);
     }
+    if (version2?.state?.updateAvailable && version2.state.canUpdate) {
+      const update = document2.createElement("button");
+      update.type = "button";
+      update.className = "settings-connection-install-link";
+      update.dataset.connectionAction = "update";
+      update.disabled = version2.updating;
+      update.title = messages.harnessVersionUpdate;
+      update.setAttribute("aria-label", `${messages.harnessVersionUpdate}: ${item.name}`);
+      update.append(createRendererSettingsIcon("download", 17));
+      update.addEventListener("click", (event) => {
+        event.stopPropagation();
+        if (update.disabled) return;
+        version2.update();
+        select();
+      });
+      action.append(update);
+    }
     if (group) {
       const toggle = document2.createElement("button");
       toggle.type = "button";
@@ -19179,6 +19662,16 @@ ${error51.stderrTail}`] : []
       });
       body.append(launchControls);
     }
+    const getGrokComputerUse = diagnostics?.getGrokComputerUse?.bind(diagnostics);
+    const setGrokComputerUse = diagnostics?.setGrokComputerUse?.bind(diagnostics);
+    if (hostId2 === "local" && agent === "grok" && getGrokComputerUse && setGrokComputerUse) {
+      body.append(
+        createGrokComputerUseControls(document2, messages, {
+          get: () => getGrokComputerUse(hostId2),
+          set: (update) => setGrokComputerUse(hostId2, update)
+        })
+      );
+    }
     inspector.append(body);
     return launchControls;
   }
@@ -19273,8 +19766,6 @@ ${error51.stderrTail}`] : []
         let selectedHostId = null;
         let selectedItemKey = null;
         let launchControls = null;
-        const versionPanels = /* @__PURE__ */ new Map();
-        const updatingVersions = /* @__PURE__ */ new Set();
         const hostNames = /* @__PURE__ */ new Map();
         let latestSnapshot = null;
         let disposeHostScroller = () => void 0;
@@ -19303,6 +19794,13 @@ ${error51.stderrTail}`] : []
           renderFrame = null;
         };
         const diagnostics = getDiagnostics();
+        const versions = createConnectionVersions(
+          document2,
+          messages,
+          context.signal,
+          diagnostics,
+          scheduleRender
+        );
         const installs = diagnostics ? harnessInstallStore(diagnostics) : null;
         const runRefresh = () => {
           if (pending || !diagnostics) return;
@@ -19439,10 +19937,13 @@ ${error51.stderrTail}`] : []
               const agent = item.agentSnapshot?.agent;
               if (!agent) return item;
               const state = installs?.get(selectedHost.hostId, agent);
+              const availability = state?.status ?? item.availability;
+              const version2 = item.agentSnapshot?.availability !== "notInstalled" && availability !== "installing" && availability !== "checking" ? versions.get(selectedHost.hostId, agent) : void 0;
               return {
                 ...item,
                 ...state ? { availability: state.status } : {},
-                ...updatingVersions.has(JSON.stringify([selectedHost.hostId, agent])) ? { availability: "updating" } : {},
+                ...version2 ? { version: version2 } : {},
+                ...version2?.updating ? { availability: "updating" } : {},
                 ...state?.error ? { installError: state.error } : {},
                 ...diagnostics?.installation && harnessHasInstallCommands(item.agentSnapshot?.plugin) ? {
                   install: () => {
@@ -19479,30 +19980,7 @@ ${error51.stderrTail}`] : []
               runRefresh
             );
             launchControls = { hostId: selectedHost.hostId, itemKey: item.key, element };
-            const agent = item.agentSnapshot?.agent;
-            const installation = diagnostics?.installation?.bind(diagnostics);
-            if (agent && item.agentSnapshot?.availability !== "notInstalled" && item.availability !== "installing" && item.availability !== "checking" && installation) {
-              const key = JSON.stringify([selectedHost.hostId, agent]);
-              let panel = versionPanels.get(key);
-              if (!panel) {
-                const hostId2 = selectedHost.hostId;
-                panel = createHarnessVersionPanel(document2, messages, context.signal, agent, {
-                  async run(action) {
-                    if (action !== "update") return installation(hostId2, agent, action);
-                    updatingVersions.add(key);
-                    if (diagnostics) render(diagnostics.snapshot());
-                    try {
-                      return await installation(hostId2, agent, action);
-                    } finally {
-                      updatingVersions.delete(key);
-                      if (!context.signal.aborted && diagnostics) render(diagnostics.snapshot());
-                    }
-                  }
-                });
-                versionPanels.set(key, panel);
-              }
-              inspector.append(panel);
-            }
+            if (item.version) inspector.append(item.version.element);
           };
           const pinnedItem = items.find((item) => item.key === "renderer-adapter");
           if (pinnedItem) {
@@ -19963,6 +20441,26 @@ ${error51.stderrTail}`] : []
     launchPathLoading: "Loading launch settings\u2026",
     launchPathLoadError: "Could not load launch settings. Reopen this detail panel to retry.",
     launchPathSaveError: "Could not save. Enter an existing absolute installation folder on this Host and check configuration permissions.",
+    grokComputerUseLabel: "Grok Computer Use",
+    grokComputerUseTitle: "Computer Use",
+    grokComputerUseDescription: "Let Grok control Mac apps via ChatGPT Computer Use (cua_repl).",
+    grokComputerUseHelp: "ChatGPT Settings \u2192 Computer use still applies to official Codex threads. Always-allowed apps stay in that list. New Grok threads pick up this switch.",
+    grokComputerUseOn: "On \xB7 available",
+    grokComputerUseOff: "Off",
+    grokComputerUseSaving: "Saving\u2026",
+    grokComputerUseLoading: "Loading Grok Computer Use\u2026",
+    grokComputerUseLoadError: "Could not load Grok Computer Use. Reopen this panel to retry.",
+    grokComputerUseSaveError: "Could not save. Install ChatGPT.app with Computer Use, then try again.",
+    grokComputerUseUnavailable: "ChatGPT Desktop Computer Use files were not found on this Mac.",
+    grokBrowserLabel: "Grok in-app browser",
+    grokBrowserTitle: "In-app browser",
+    grokBrowserDescription: "Let Grok use ChatGPT's built-in browser (Browser Use) through cua_repl. Independent of Computer Use.",
+    grokBrowserHelp: "Official Codex Browser Use is unchanged. Grok fails closed when ChatGPT does not authorize the connection or no in-app browser tab can be bound. The Chrome extension is a separate path.",
+    grokBrowserOn: "On \xB7 browser surface enabled",
+    grokBrowserOff: "Off",
+    grokBrowserUnavailable: "ChatGPT Desktop in-app browser files were not found on this Mac.",
+    grokBrowserBlocked: "Saved as intent. ChatGPT Desktop does not authorize Grok to use the in-app browser.",
+    grokComputerUseApplyFailed: "Could not apply the saved setting to Grok config.",
     connectionOfficialWebsite: "Visit official website",
     connectionOpenHarnessWeb: "Open DeepSeek Harness Web",
     connectionDeepSeekTestedVersions: "Supported DSH versions: 0.1.7-rc.1, 0.1.7-rc.2, 0.2.0-rc.1, 0.2.0-rc.2, 0.2.1-rc.1 and 0.2.1-rc.2. Versions newer than 0.2.1-rc.2 can be tried, but compatibility may be limited; versions older than 0.1.7-rc.1 must be upgraded first.",
@@ -19974,6 +20472,7 @@ ${error51.stderrTail}`] : []
     harnessVersionCurrent: "Current version",
     harnessVersionLatest: "Latest version",
     harnessVersionChecking: "Checking versions\u2026",
+    harnessVersionAvailable: "Update available",
     harnessVersionUpdate: "Update",
     harnessVersionUpdating: "Updating\u2026",
     harnessVersionUpToDate: "Up to date",
@@ -20245,6 +20744,26 @@ ${error51.stderrTail}`] : []
     launchPathLoading: "\u6B63\u5728\u8BFB\u53D6\u542F\u52A8\u8BBE\u7F6E\u2026",
     launchPathLoadError: "\u65E0\u6CD5\u8BFB\u53D6\u542F\u52A8\u8BBE\u7F6E\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u6B64\u8BE6\u60C5\u9762\u677F\u91CD\u8BD5\u3002",
     launchPathSaveError: "\u4FDD\u5B58\u5931\u8D25\u3002\u8BF7\u586B\u5199\u6B64 Host \u4E0A\u5B9E\u9645\u5B58\u5728\u7684\u5B89\u88C5\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5E76\u786E\u8BA4\u914D\u7F6E\u76EE\u5F55\u53EF\u5199\u3002",
+    grokComputerUseLabel: "Grok Computer Use",
+    grokComputerUseTitle: "Computer Use",
+    grokComputerUseDescription: "\u8BA9 Grok \u901A\u8FC7 ChatGPT Computer Use\uFF08cua_repl\uFF09\u63A7\u5236 Mac \u5E94\u7528\u3002",
+    grokComputerUseHelp: "ChatGPT \u8BBE\u7F6E \u2192 Computer use \u4ECD\u53EA\u4F5C\u7528\u4E8E\u5B98\u65B9 Codex \u7EBF\u7A0B\u3002Always-allowed \u5E94\u7528\u4ECD\u4FDD\u5B58\u5728\u8BE5\u5217\u8868\u3002\u65B0\u7684 Grok \u7EBF\u7A0B\u4F1A\u8BFB\u53D6\u6B64\u5F00\u5173\u3002",
+    grokComputerUseOn: "\u5DF2\u5F00\u542F \xB7 \u53EF\u7528",
+    grokComputerUseOff: "\u5DF2\u5173\u95ED",
+    grokComputerUseSaving: "\u6B63\u5728\u4FDD\u5B58\u2026",
+    grokComputerUseLoading: "\u6B63\u5728\u8BFB\u53D6 Grok Computer Use\u2026",
+    grokComputerUseLoadError: "\u65E0\u6CD5\u8BFB\u53D6 Grok Computer Use\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u6B64\u9762\u677F\u91CD\u8BD5\u3002",
+    grokComputerUseSaveError: "\u4FDD\u5B58\u5931\u8D25\u3002\u8BF7\u5148\u5B89\u88C5\u5E26 Computer Use \u7684 ChatGPT.app\u3002",
+    grokComputerUseUnavailable: "\u672C\u673A\u672A\u627E\u5230 ChatGPT Desktop \u7684 Computer Use \u6587\u4EF6\u3002",
+    grokBrowserLabel: "Grok \u5185\u7F6E\u6D4F\u89C8\u5668",
+    grokBrowserTitle: "\u5185\u7F6E\u6D4F\u89C8\u5668",
+    grokBrowserDescription: "\u8BA9 Grok \u901A\u8FC7 cua_repl \u4F7F\u7528 ChatGPT \u5185\u7F6E\u6D4F\u89C8\u5668\uFF08Browser Use\uFF09\u3002\u4E0E Computer Use \u76F8\u4E92\u72EC\u7ACB\u3002",
+    grokBrowserHelp: "\u5B98\u65B9 Codex Browser Use \u4E0D\u53D7\u5F71\u54CD\u3002ChatGPT \u4E0D\u6388\u6743\u8FDE\u63A5\u6216\u65E0\u6CD5\u7ED1\u5B9A\u5185\u7F6E\u6D4F\u89C8\u5668\u6807\u7B7E\u9875\u65F6\uFF0CGrok \u4F1A\u76F4\u63A5\u5931\u8D25\u3002Chrome \u6269\u5C55\u662F\u53E6\u4E00\u6761\u8DEF\u5F84\u3002",
+    grokBrowserOn: "\u5DF2\u5F00\u542F \xB7 \u6D4F\u89C8\u5668\u80FD\u529B\u5DF2\u542F\u7528",
+    grokBrowserOff: "\u5DF2\u5173\u95ED",
+    grokBrowserUnavailable: "\u672C\u673A\u672A\u627E\u5230 ChatGPT Desktop \u7684\u5185\u7F6E\u6D4F\u89C8\u5668\u6587\u4EF6\u3002",
+    grokBrowserBlocked: "\u5DF2\u4FDD\u5B58\u4E3A\u610F\u5411\u3002ChatGPT Desktop \u5C1A\u672A\u6388\u6743 Grok \u4F7F\u7528\u5185\u7F6E\u6D4F\u89C8\u5668\u3002",
+    grokComputerUseApplyFailed: "\u65E0\u6CD5\u5C06\u5DF2\u4FDD\u5B58\u7684\u8BBE\u7F6E\u5199\u5165 Grok \u914D\u7F6E\u3002",
     connectionOfficialWebsite: "\u8BBF\u95EE\u5B98\u7F51",
     connectionOpenHarnessWeb: "\u6253\u5F00 DeepSeek Harness Web",
     connectionDeepSeekTestedVersions: "\u652F\u6301 DSH \u7248\u672C\uFF1A0.1.7-rc.1\u30010.1.7-rc.2\u30010.2.0-rc.1\u30010.2.0-rc.2\u30010.2.1-rc.1 \u548C 0.2.1-rc.2\u3002\u9AD8\u4E8E 0.2.1-rc.2 \u7684\u7248\u672C\u53EF\u4EE5\u5C1D\u8BD5\u8FDE\u63A5\uFF0C\u4F46\u9002\u914D\u5EA6\u53EF\u80FD\u6709\u9650\uFF1B\u4F4E\u4E8E 0.1.7-rc.1 \u7684\u7248\u672C\u9700\u8981\u5148\u5347\u7EA7\u3002",
@@ -20256,6 +20775,7 @@ ${error51.stderrTail}`] : []
     harnessVersionCurrent: "\u5F53\u524D\u7248\u672C",
     harnessVersionLatest: "\u6700\u65B0\u7248\u672C",
     harnessVersionChecking: "\u6B63\u5728\u68C0\u67E5\u7248\u672C\u2026",
+    harnessVersionAvailable: "\u6709\u65B0\u7248\u672C",
     harnessVersionUpdate: "\u66F4\u65B0",
     harnessVersionUpdating: "\u6B63\u5728\u66F4\u65B0\u2026",
     harnessVersionUpToDate: "\u5DF2\u662F\u6700\u65B0",
@@ -24791,7 +25311,15 @@ Codex Fast mode prioritizes requests and may increase usage.`
     };
     const inspectHarness = async (input, options) => {
       const params = harnessInspectParamsSchema.parse(input);
-      const result = await manager.sendRequest(HARNESS_INSPECT_METHOD, params, options);
+      let result;
+      try {
+        result = await manager.sendRequest(HARNESS_INSPECT_METHOD, params, options);
+      } catch (error51) {
+        if (!params.purpose || !isInvalidParams(error51)) throw error51;
+        const full = { ...params };
+        delete full.purpose;
+        result = await manager.sendRequest(HARNESS_INSPECT_METHOD, full, options);
+      }
       return harnessInspectionSchema.parse(result);
     };
     const inspectHarnessCommands = async (input) => {
@@ -24865,6 +25393,19 @@ Codex Fast mode prioritizes requests and may increase usage.`
           )
         );
       },
+      async getGrokComputerUse() {
+        return grokComputerUseSettingsSchema.parse(
+          await manager.sendRequest(GROK_COMPUTER_USE_GET_METHOD, {})
+        );
+      },
+      async setGrokComputerUse(update) {
+        return grokComputerUseSettingsSchema.parse(
+          await manager.sendRequest(
+            GROK_COMPUTER_USE_SET_METHOD,
+            grokComputerUseSetSchema.parse(update)
+          )
+        );
+      },
       async listLoadedSessions() {
         return loadedSessionsSchema.parse(await manager.sendRequest(LOADED_SESSIONS_METHOD, {}));
       },
@@ -25053,6 +25594,9 @@ Codex Fast mode prioritizes requests and may increase usage.`
       }
     });
   }
+  function isInvalidParams(error51) {
+    return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === -32602;
+  }
 
   // src/renderer-external-queue.ts
   function isRecord8(value) {
@@ -27164,104 +27708,6 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
     return element;
   }
 
-  // src/settings/preference-ui.ts
-  var nextPreferenceId = 0;
-  function preferenceId(prefix) {
-    nextPreferenceId += 1;
-    return `codexhost-${prefix}-${nextPreferenceId}`;
-  }
-  function createPreferenceGroup(document2, title) {
-    const group = document2.createElement("section");
-    group.className = "mt-7 first-of-type:mt-0";
-    const header = document2.createElement("div");
-    header.className = "mb-2 flex min-h-6 items-center gap-2 px-1";
-    const heading = document2.createElement("h3");
-    heading.id = preferenceId("preference-group");
-    heading.className = "m-0 text-[13px] leading-5 font-semibold text-settings-text";
-    heading.textContent = title;
-    header.append(heading);
-    const card = document2.createElement("div");
-    card.className = "rounded-[10px] border border-settings-border bg-settings-panel";
-    group.setAttribute("aria-labelledby", heading.id);
-    group.append(header, card);
-    return { group, header, card };
-  }
-  function createPreferenceItem(document2, input) {
-    const item = document2.createElement("div");
-    item.className = "flex min-h-[60px] items-center justify-between gap-6 border-t border-settings-divider px-4 py-3 first:border-t-0";
-    const copy = document2.createElement("div");
-    copy.className = "flex min-w-0 flex-col gap-0.5";
-    const heading = document2.createElement("div");
-    heading.className = "flex items-center gap-1.5";
-    const title = document2.createElement("label");
-    title.htmlFor = input.controlId;
-    title.className = "cursor-pointer text-[13px] leading-5 font-medium text-settings-text";
-    title.textContent = input.title;
-    heading.append(title);
-    if (input.help) heading.append(createHelpTooltip(document2, input.help.label, input.help.lines));
-    const description = document2.createElement("div");
-    description.id = preferenceId("preference-description");
-    description.className = "text-xs leading-[18px] text-settings-muted data-[invalid=true]:text-settings-danger";
-    description.textContent = input.description;
-    copy.append(heading, description);
-    item.append(copy);
-    return { item, description };
-  }
-  function createHelpTooltip(document2, label, lines) {
-    const wrapper = document2.createElement("span");
-    wrapper.className = "group relative inline-flex";
-    const button2 = document2.createElement("button");
-    button2.type = "button";
-    button2.className = "inline-flex size-4 cursor-help items-center justify-center rounded-full border-0 bg-transparent p-0 text-settings-subtle transition-colors hover:text-settings-text focus-visible:text-settings-text focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-settings-focus";
-    button2.setAttribute("aria-label", label);
-    button2.append(createRendererSettingsIcon("help", 14));
-    const tooltip = document2.createElement("div");
-    tooltip.id = preferenceId("preference-tooltip");
-    tooltip.setAttribute("role", "tooltip");
-    tooltip.className = "pointer-events-none invisible absolute top-full left-0 z-20 mt-2 w-80 rounded-lg border border-settings-border bg-settings-panel px-3 py-2.5 text-xs leading-[18px] font-normal text-settings-text opacity-0 shadow-[0_10px_30px_rgb(0_0_0/0.22)] transition-opacity duration-150 group-hover:visible group-hover:opacity-100 group-focus-within:visible group-focus-within:opacity-100";
-    const list = document2.createElement("ul");
-    list.className = "m-0 grid list-disc gap-1 pl-4 marker:text-settings-subtle";
-    for (const line of lines) {
-      const item = document2.createElement("li");
-      item.textContent = line;
-      list.append(item);
-    }
-    tooltip.append(list);
-    button2.setAttribute("aria-describedby", tooltip.id);
-    button2.addEventListener("keydown", (event) => {
-      if (event.key === "Escape") button2.blur();
-    });
-    wrapper.append(button2, tooltip);
-    return wrapper;
-  }
-  function createPreferenceSwitch(document2, id, describedBy) {
-    const input = document2.createElement("input");
-    input.type = "checkbox";
-    input.id = id;
-    input.setAttribute("role", "switch");
-    input.setAttribute("aria-describedby", describedBy);
-    input.className = "relative m-0 h-5 w-9 shrink-0 cursor-pointer appearance-none rounded-full bg-settings-surface-hover ring-1 ring-settings-border transition-colors ring-inset before:absolute before:top-0.5 before:left-0.5 before:size-4 before:rounded-full before:bg-white before:shadow-[0_1px_2px_rgb(0_0_0/0.3)] before:transition-transform checked:bg-settings-focus checked:ring-transparent checked:before:translate-x-4 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-settings-focus";
-    return input;
-  }
-  function createNumberField(document2, input) {
-    const field = document2.createElement("div");
-    field.className = "flex h-8 shrink-0 items-center gap-1.5 rounded-md border border-settings-border bg-settings-surface px-2.5 transition-colors focus-within:border-settings-focus data-[invalid=true]:border-settings-danger";
-    const control = document2.createElement("input");
-    control.type = "number";
-    control.id = input.id;
-    control.min = String(input.min);
-    control.max = String(input.max);
-    control.step = "1";
-    control.setAttribute("aria-describedby", input.describedBy);
-    control.className = "w-14 border-0 bg-transparent p-0 text-right text-[13px] leading-5 text-settings-text tabular-nums outline-none";
-    const unit = document2.createElement("span");
-    unit.className = "text-xs text-settings-muted";
-    unit.setAttribute("aria-hidden", "true");
-    unit.textContent = input.unit;
-    field.append(control, unit);
-    return { field, control };
-  }
-
   // src/settings/voice-messages.ts
   function voiceMessages(locale) {
     const en = {
@@ -27283,6 +27729,15 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       configured: "Configured",
       needsSetup: "Needs setup",
       unknown: "Not checked",
+      gatewayStatus: "Gateway configuration",
+      preferencesStatus: "Preferences applied",
+      hookStatus: "Desktop gateway voice integration",
+      preferencesOn: "Applied",
+      preferencesOff: "Not applied yet",
+      hookSupported: "Supported",
+      hookUnsupported: "This Desktop build is not supported for gateway voice",
+      hookPending: "Attaching\u2026",
+      hookDisabled: "Off",
       configure: "Configure",
       setup: "Gateway setup",
       setupHint: "Gateway settings use your local Codex configuration and the selected provider\u2019s credential. End voice before editing configuration. Never paste credentials here.",
@@ -27333,6 +27788,15 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       configured: "\u5DF2\u914D\u7F6E",
       needsSetup: "\u9700\u8981\u914D\u7F6E",
       unknown: "\u672A\u68C0\u67E5",
+      gatewayStatus: "\u7F51\u5173\u914D\u7F6E",
+      preferencesStatus: "\u504F\u597D\u662F\u5426\u5DF2\u5E94\u7528",
+      hookStatus: "Desktop \u7F51\u5173\u8BED\u97F3\u96C6\u6210",
+      preferencesOn: "\u5DF2\u5E94\u7528",
+      preferencesOff: "\u5C1A\u672A\u5E94\u7528",
+      hookSupported: "\u652F\u6301",
+      hookUnsupported: "\u5F53\u524D Desktop \u7248\u672C\u4E0D\u652F\u6301\u7F51\u5173\u8BED\u97F3",
+      hookPending: "\u6B63\u5728\u63A5\u5165\u2026",
+      hookDisabled: "\u5DF2\u5173\u95ED",
       configure: "\u914D\u7F6E",
       setup: "\u7F51\u5173\u914D\u7F6E",
       setupHint: "\u7F51\u5173\u4F7F\u7528\u672C\u5730 Codex \u914D\u7F6E\u53CA\u6240\u9009 Provider \u7684\u51ED\u636E\u3002\u7F16\u8F91\u524D\u8BF7\u7ED3\u675F\u8BED\u97F3\u3002\u8BF7\u52FF\u5728\u6B64\u7C98\u8D34\u51ED\u636E\u3002",
@@ -27532,20 +27996,30 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
           });
           configure.id = gateway.item.querySelector("label")?.htmlFor ?? "";
           configure.setAttribute("aria-expanded", String(setup));
+          const gatewayReadyLabel = state.gatewayReady === null ? m.unknown : state.gatewayReady ? m.configured : m.needsSetup;
           const gatewayActions = h(
             doc,
             "div",
             { className: "settings-voice__gateway-actions" },
+            h(doc, "span", {}, gatewayReadyLabel),
+            configure
+          );
+          gateway.item.append(gatewayActions);
+          config2.card.append(gateway.item);
+          const hook = options.desktop ? desktopVoiceHookStatus(doc.defaultView) : "unknown";
+          const hookLabel = hook === "active" ? m.hookSupported : hook === "pending" ? m.hookPending : hook === "unsupported" ? m.hookUnsupported : hook === "disabled" ? m.hookDisabled : m.unknown;
+          const health = h(doc, "div", { className: "settings-voice__health" });
+          health.append(
+            h(doc, "p", {}, `${m.gatewayStatus}: ${gatewayReadyLabel}`),
             h(
               doc,
-              "span",
+              "p",
               {},
-              state.gatewayReady === null ? m.unknown : state.gatewayReady ? m.configured : m.needsSetup
+              `${m.preferencesStatus}: ${state.routesActive === true ? m.preferencesOn : state.routesActive === false ? m.preferencesOff : m.unknown}`
             ),
-            configure
+            h(doc, "p", {}, `${m.hookStatus}: ${hookLabel}`)
           );
-          gateway.item.append(gatewayActions);
-          config2.card.append(gateway.item);
+          config2.card.append(health);
           if (setup) {
             const details = h(
               doc,
@@ -27675,6 +28149,15 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       }
     });
   }
+  function desktopVoiceHookStatus(win) {
+    if (!win) return "unknown";
+    const value = win.__codexhostClientOwnedVoiceV1;
+    if (!value || typeof value !== "object") return "unknown";
+    const status = value.status;
+    if (status === "active" || status === "pending" || status === "unsupported" || status === "disabled")
+      return status;
+    return "unknown";
+  }
 
   // src/console/usage/model-labels.ts
   function usageModelLabel(model2, labels, harness2) {
@@ -30061,6 +30544,13 @@ ${detail}` : ""}`
     save: "Save",
     useAutomatic: "Use automatic",
     saved: "Saved",
+    grokComputerUse: "Grok Computer Use",
+    grokComputerUseHelp: "Lets Grok control Mac apps through ChatGPT\u2019s Computer Use helper. ChatGPT Settings \u2192 Computer use still applies only to official Codex. New Grok threads pick up this switch.",
+    grokComputerUseUnavailable: "ChatGPT Desktop Computer Use files were not found.",
+    grokBrowser: "Grok in-app browser",
+    grokBrowserHelp: "Lets Grok use ChatGPT\u2019s built-in browser (Browser Use) through cua_repl. Independent of Computer Use; official Codex Browser Use is unchanged. Grok fails closed when the in-app tab cannot be bound.",
+    grokBrowserUnavailable: "ChatGPT Desktop in-app browser files were not found.",
+    grokBrowserBlocked: "Saved as intent. ChatGPT Desktop does not authorize Grok to use the in-app browser.",
     installGuide: "Install guide",
     noHarness: "No Harness plugins are installed.",
     consoleOffline: "The console is not running",
@@ -30250,6 +30740,13 @@ ${detail}` : ""}`
     save: "\u4FDD\u5B58",
     useAutomatic: "\u6062\u590D\u81EA\u52A8\u67E5\u627E",
     saved: "\u5DF2\u4FDD\u5B58",
+    grokComputerUse: "Grok Computer Use",
+    grokComputerUseHelp: "\u8BA9 Grok \u901A\u8FC7 ChatGPT \u7684 Computer Use \u52A9\u624B\u63A7\u5236 Mac \u5E94\u7528\u3002ChatGPT \u8BBE\u7F6E \u2192 Computer use \u4ECD\u53EA\u4F5C\u7528\u4E8E\u5B98\u65B9 Codex\u3002\u65B0\u7684 Grok \u7EBF\u7A0B\u4F1A\u8BFB\u53D6\u6B64\u5F00\u5173\u3002",
+    grokComputerUseUnavailable: "\u672A\u627E\u5230 ChatGPT Desktop \u7684 Computer Use \u6587\u4EF6\u3002",
+    grokBrowser: "Grok \u5185\u7F6E\u6D4F\u89C8\u5668",
+    grokBrowserHelp: "\u8BA9 Grok \u901A\u8FC7 cua_repl \u4F7F\u7528 ChatGPT \u5185\u7F6E\u6D4F\u89C8\u5668\uFF08Browser Use\uFF09\u3002\u4E0E Computer Use \u76F8\u4E92\u72EC\u7ACB\uFF0C\u5B98\u65B9 Codex Browser Use \u4E0D\u53D7\u5F71\u54CD\u3002\u65E0\u6CD5\u7ED1\u5B9A\u5185\u7F6E\u6807\u7B7E\u9875\u65F6 Grok \u4F1A\u76F4\u63A5\u5931\u8D25\u3002",
+    grokBrowserUnavailable: "\u672A\u627E\u5230 ChatGPT Desktop \u7684\u5185\u7F6E\u6D4F\u89C8\u5668\u6587\u4EF6\u3002",
+    grokBrowserBlocked: "\u5DF2\u4FDD\u5B58\u4E3A\u610F\u5411\u3002ChatGPT Desktop \u5C1A\u672A\u6388\u6743 Grok \u4F7F\u7528\u5185\u7F6E\u6D4F\u89C8\u5668\u3002",
     installGuide: "\u5B89\u88C5\u8BF4\u660E",
     noHarness: "\u6CA1\u6709\u5DF2\u5B89\u88C5\u7684 Harness \u63D2\u4EF6\u3002",
     consoleOffline: "\u63A7\u5236\u53F0\u672A\u8FD0\u884C",
@@ -32663,7 +33160,7 @@ ${detail}` : ""}`
   }
   function defaultImportName(source, existing) {
     const base = source.provider === "openai-codex" ? "codex" : "grok";
-    const used = new Set(existing.map((record6) => record6.name));
+    const used = new Set(existing.map((record7) => record7.name));
     const valid = (name) => credentialImportNameSchema.safeParse(name).success;
     if (!used.has(base)) return base;
     const local = source.label.includes("@") ? source.label.split("@")[0] ?? "" : "";
@@ -32686,7 +33183,7 @@ ${detail}` : ""}`
     const shown = (text) => accountDisplayText(text, hideEmails);
     const targetButtons = /* @__PURE__ */ new Map();
     const importedRecords = () => snapshot.targets.find((target) => target.harnessId === TARGET_HARNESS_ID)?.imports ?? [];
-    const sourceOf = (record6) => snapshot.sources.find((source) => source.id === record6.source.id);
+    const sourceOf = (record7) => snapshot.sources.find((source) => source.id === record7.source.id);
     const piTarget = () => snapshot.targets.find((candidate) => candidate.harnessId === TARGET_HARNESS_ID);
     const compatibleSources = () => {
       const target = piTarget();
@@ -32724,7 +33221,7 @@ ${detail}` : ""}`
     sectionImport.addEventListener("click", () => {
       const sources = compatibleSources();
       const free = sources.find(
-        (source2) => !importedRecords().some((record6) => record6.source.id === source2.id)
+        (source2) => !importedRecords().some((record7) => record7.source.id === source2.id)
       );
       const source = free ?? sources[0];
       if (source) openDialog("add", { source, choose: true }, SECTION_IMPORT_KEY);
@@ -32774,30 +33271,30 @@ ${detail}` : ""}`
       mark.append(createRendererAgentIcon(agent ?? "pi", 26, document2, pluginFor(agent ?? "pi")));
       return mark;
     };
-    const renderRow = (record6) => {
+    const renderRow = (record7) => {
       const row = document2.createElement("div");
       row.className = "settings-pi-accounts__row";
       row.tabIndex = -1;
-      row.dataset.importName = record6.name;
-      row.setAttribute("aria-label", shown(record6.source.label));
-      const agent = record6.source.harnessId;
+      row.dataset.importName = record7.name;
+      row.setAttribute("aria-label", shown(record7.source.label));
+      const agent = record7.source.harnessId;
       const mark = createMark(agent);
       const identity = document2.createElement("div");
       identity.className = "settings-pi-accounts__identity";
       const label = document2.createElement("strong");
       label.className = "settings-account-email";
-      label.textContent = shown(record6.source.label);
+      label.textContent = shown(record7.source.label);
       label.title = label.textContent;
       label.translate = false;
       const meta3 = document2.createElement("div");
       meta3.className = "settings-account-metadata";
-      const source = sourceOf(record6);
+      const source = sourceOf(record7);
       const parts = [
         metaPart(rendererAgentLabel(agent, pluginFor(agent)), "settings-pi-accounts__agent"),
-        metaPart(`${record6.name}/\u2026`, void 0, true),
+        metaPart(`${record7.name}/\u2026`, void 0, true),
         metaPart(messages.copied)
       ];
-      const time3 = formatImportedAt(record6.importedAt);
+      const time3 = formatImportedAt(record7.importedAt);
       if (time3) parts.push(metaPart(time3));
       parts.forEach((part, index) => {
         if (index > 0) {
@@ -32814,23 +33311,23 @@ ${detail}` : ""}`
       reimport.type = "button";
       reimport.className = "settings-account-action";
       reimport.textContent = messages.rowReimport;
-      reimport.setAttribute("aria-label", `${messages.reimport}: ${shown(record6.source.label)}`);
+      reimport.setAttribute("aria-label", `${messages.reimport}: ${shown(record7.source.label)}`);
       reimport.disabled = busy || !source;
       reimport.title = messages.reimport;
       reimport.addEventListener("click", () => {
-        if (source) openDialog("reimport", { source, record: record6 }, `row:${record6.name}`);
+        if (source) openDialog("reimport", { source, record: record7 }, `row:${record7.name}`);
       });
       const remove = document2.createElement("button");
       remove.type = "button";
       remove.className = "settings-account-action settings-pi-accounts__remove";
       remove.textContent = messages.rowRemove;
-      remove.setAttribute("aria-label", `${messages.remove}: ${shown(record6.source.label)}`);
+      remove.setAttribute("aria-label", `${messages.remove}: ${shown(record7.source.label)}`);
       remove.disabled = busy;
-      remove.addEventListener("click", () => openDialog("remove", { record: record6 }, `row:${record6.name}`));
+      remove.addEventListener("click", () => openDialog("remove", { record: record7 }, `row:${record7.name}`));
       if (source) actions.append(reimport);
       actions.append(remove);
       row.append(mark, identity, actions);
-      rows.set(record6.name, row);
+      rows.set(record7.name, row);
       return row;
     };
     const loginTypeLabel = (type) => type === "oauth" ? messages.typeOauth : type === "api_key" ? messages.typeApiKey : messages.typeOther;
@@ -32983,7 +33480,7 @@ ${detail}` : ""}`
           const label = document2.createElement("strong");
           label.textContent = shown(choice.label);
           label.translate = false;
-          const existing = importedRecords().find((record6) => record6.source.id === choice.id);
+          const existing = importedRecords().find((record7) => record7.source.id === choice.id);
           const agent = choice.harnessId;
           const detail = document2.createElement("span");
           detail.textContent = [
@@ -33024,7 +33521,7 @@ ${detail}` : ""}`
           const name = request.action === "list" ? void 0 : request.name;
           state = {
             source: state.source,
-            record: importedRecords().find((record6) => record6.name === name) ?? state.record
+            record: importedRecords().find((record7) => record7.name === name) ?? state.record
           };
           show(next);
         } else {
@@ -33038,12 +33535,12 @@ ${detail}` : ""}`
         sourceRadios = [];
         body.replaceChildren();
         controls.replaceChildren();
-        const { source, record: record6 } = state;
+        const { source, record: record7 } = state;
         const close = () => modal.close();
         if (mode === "add" || mode === "reimport") {
           title.textContent = mode === "add" ? messages.add : messages.reimport;
           modal.setAttribute("aria-label", title.textContent);
-          const active = source ?? record6?.source;
+          const active = source ?? record7?.source;
           const choices = mode === "add" && state.choose ? compatibleSources() : [];
           if (choices.length > 1) body.append(sourcePicker(choices));
           else if (active) body.append(line(messages.source, shown(active.label)));
@@ -33052,8 +33549,8 @@ ${detail}` : ""}`
           input.maxLength = 48;
           input.autocomplete = "off";
           input.spellcheck = false;
-          input.value = record6?.name ?? (source ? defaultImportName(source, importedRecords()) : "codex");
-          input.readOnly = Boolean(record6);
+          input.value = record7?.name ?? (source ? defaultImportName(source, importedRecords()) : "codex");
+          input.readOnly = Boolean(record7);
           input.addEventListener("input", () => {
             nameEdited = true;
           });
@@ -33087,7 +33584,7 @@ ${detail}` : ""}`
                   {
                     action: mode === "reimport" ? "reimport" : "import",
                     sourceId: source2.id,
-                    name: record6?.name ?? input.value,
+                    name: record7?.name ?? input.value,
                     confirmed: true
                   },
                   "done"
@@ -33097,16 +33594,16 @@ ${detail}` : ""}`
             )
           );
           (mode === "add" ? input : controls.children[0]).focus();
-        } else if (mode === "remove" && record6) {
+        } else if (mode === "remove" && record7) {
           title.textContent = messages.remove;
           modal.setAttribute("aria-label", title.textContent);
-          body.append(note(messages.removeWarning.replace("{name}", record6.name)));
+          body.append(note(messages.removeWarning.replace("{name}", record7.name)));
           const cancel = command(messages.cancel, close);
           controls.append(
             cancel,
             command(
               messages.remove,
-              () => submit({ action: "remove", name: record6.name, confirmed: true }, null),
+              () => submit({ action: "remove", name: record7.name, confirmed: true }, null),
               "danger"
             )
           );
@@ -33114,7 +33611,7 @@ ${detail}` : ""}`
         } else {
           title.textContent = messages.doneTitle;
           modal.setAttribute("aria-label", title.textContent);
-          const name = record6?.name;
+          const name = record7?.name;
           if (name) body.append(line(messages.entry, `${name}/\u2026`, true));
           body.append(note(messages.done));
           const done = command(messages.close, close, "primary");
@@ -33161,21 +33658,21 @@ ${detail}` : ""}`
           (candidate) => candidate.harnessId === TARGET_HARNESS_ID && source && candidate.providers.includes(source.provider)
         );
         if (!source || !target) return null;
-        const record6 = target.imports.find((candidate) => candidate.source.id === source.id);
+        const record7 = target.imports.find((candidate) => candidate.source.id === source.id);
         const key = `${harnessId}:${accountLabel}:import`;
         const button2 = document2.createElement("button");
         button2.type = "button";
         button2.className = "settings-account-pi-import";
         button2.dataset.accountFocus = key;
         button2.disabled = busy;
-        const hint = record6 ? messages.importedHint.replace("{name}", record6.name) : messages.add;
+        const hint = record7 ? messages.importedHint.replace("{name}", record7.name) : messages.add;
         button2.title = hint;
         button2.setAttribute("aria-label", hint);
         button2.append(createRendererAgentIcon("pi", 12, document2, pluginFor("pi")));
-        if (record6) {
+        if (record7) {
           button2.dataset.state = "imported";
           const name = document2.createElement("code");
-          name.textContent = `${record6.name}/\u2026`;
+          name.textContent = `${record7.name}/\u2026`;
           name.translate = false;
           button2.append(name, createRendererSettingsIcon("check", 12));
         } else {
@@ -33183,7 +33680,7 @@ ${detail}` : ""}`
           button2.append(messages.add);
         }
         button2.addEventListener("click", () => {
-          if (!record6) {
+          if (!record7) {
             openDialog("add", { source }, key);
             return;
           }
@@ -33192,7 +33689,7 @@ ${detail}` : ""}`
             renderSection();
             sectionToggle.setAttribute("aria-expanded", "true");
           }
-          const row = rows.get(record6.name);
+          const row = rows.get(record7.name);
           row?.scrollIntoView({ block: "nearest", behavior: "smooth" });
           row?.focus();
         });
@@ -35749,6 +36246,17 @@ ${detail}` : ""}`
   line-height: 18px;
 }
 
+.settings-connection-row__status:has(.settings-connection-version-available) {
+  flex-wrap: wrap;
+  max-width: 160px;
+}
+
+.settings-connection-version-available {
+  flex-basis: 100%;
+  color: var(--settings-focus);
+  overflow-wrap: anywhere;
+}
+
 .settings-connection-row__status::before {
   width: 6px;
   height: 6px;
@@ -36092,6 +36600,69 @@ ${detail}` : ""}`
   gap: 8px;
 }
 
+.settings-grok-computer-use {
+  display: grid;
+  gap: 10px;
+  min-width: 0;
+  margin-top: 4px;
+  padding: 12px;
+  background: var(--settings-surface);
+  border: 1px solid var(--settings-divider);
+  border-radius: 12px;
+}
+
+.settings-grok-computer-use__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.settings-grok-computer-use__copy {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.settings-grok-computer-use__title {
+  margin: 0;
+  color: var(--settings-text);
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 20px;
+}
+
+.settings-grok-computer-use__description {
+  margin: 0;
+  color: var(--settings-muted);
+  font-size: 13px;
+  line-height: 18px;
+  overflow-wrap: anywhere;
+}
+
+.settings-grok-computer-use__help,
+.settings-grok-computer-use__status {
+  margin: 0;
+  color: var(--settings-subtle);
+  font-size: 12px;
+  line-height: 16px;
+  overflow-wrap: anywhere;
+}
+
+.settings-grok-computer-use__help {
+  padding-top: 8px;
+  border-top: 1px solid var(--settings-divider);
+}
+
+.settings-grok-computer-use__browser {
+  padding-top: 8px;
+  border-top: 1px solid var(--settings-divider);
+}
+
+.settings-grok-computer-use__status[data-state="on"] {
+  color: var(--settings-success);
+}
+
 .settings-connection-install-callout {
   display: grid;
   grid-template-columns: 28px minmax(0, 1fr);
@@ -37341,6 +37912,19 @@ ${detail}` : ""}`
   border-top: 1px solid var(--settings-divider);
   font-size: 13px;
 }
+.settings-voice__health {
+  display: grid;
+  gap: 4px;
+  margin: 8px 12px 12px;
+  color: var(--settings-subtle);
+  font-size: 12px;
+  line-height: 16px;
+}
+
+.settings-voice__health p {
+  margin: 0;
+}
+
 .settings-voice__footer p,
 .settings-voice__hint {
   margin: 4px 0 0;
@@ -39707,7 +40291,7 @@ th[aria-sort] .console-usage-sort__mark {
     place();
     const observer = ownerWindow ? new ownerWindow.MutationObserver((records) => {
       const titlebar = source?.closest("[data-app-shell-titlebar]");
-      if (!source?.isConnected || records.some((record6) => titlebar?.contains(record6.target))) {
+      if (!source?.isConnected || records.some((record7) => titlebar?.contains(record7.target))) {
         place();
       }
     }) : null;
@@ -42474,7 +43058,7 @@ ${usage_default}`;
             let webUiAvailable = false;
             try {
               const inspection = await client.inspectHarness(
-                { harnessId: harnessIdSchema.parse(agent), refresh },
+                { harnessId: harnessIdSchema.parse(agent), refresh, purpose: "availability" },
                 { priority: "background" }
               );
               status = inspection.status === "ready" ? "ready" : inspection.status;
@@ -42693,6 +43277,18 @@ ${usage_default}`;
         if (!client?.setHarnessLaunchSettings) throw new Error("Launch settings are unavailable");
         return client.setHarnessLaunchSettings({ harnessId: harnessIdSchema.parse(agent), path });
       },
+      async getGrokComputerUse(hostId2) {
+        const client = hostId2 === "local" ? modelClientForHost(hostId2) : null;
+        if (!client?.getGrokComputerUse)
+          throw new Error("Grok Computer Use settings are unavailable");
+        return client.getGrokComputerUse();
+      },
+      async setGrokComputerUse(hostId2, update) {
+        const client = hostId2 === "local" ? modelClientForHost(hostId2) : null;
+        if (!client?.setGrokComputerUse)
+          throw new Error("Grok Computer Use settings are unavailable");
+        return client.setGrokComputerUse(update);
+      },
       async openWebUi(hostId2, agent) {
         const state = hostHarnessAvailabilityState(hostId2);
         const client = hostId2 === "local" ? modelClientForHost(hostId2) : null;
@@ -43335,6 +43931,18 @@ ${usage_default}`;
   // src/renderer-external-voice-launch.ts
   var HOOK_GLOBAL3 = "__codexhostExternalVoiceLaunchV1";
   var SHARED_ASSET = "app-shared-8bd9d0399038.js";
+  var LAUNCH_ASSETS = [
+    ...CLIENT_OWNED_VOICE_ASSETS.map((profile) => ({
+      ...profile,
+      services: CLIENT_OWNED_VOICE_SERVICES
+    })),
+    {
+      version: AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION,
+      initial: AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET,
+      shared: SHARED_ASSET,
+      services: "fN"
+    }
+  ];
   function isRecord16(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
@@ -43373,7 +43981,7 @@ ${usage_default}`;
     const config2 = readCpaLiveVoiceHookConfig(target);
     if (!config2) return { status: "disabled", dispose() {
     } };
-    if (config2.auditedDesktopVersion !== AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION || config2.auditedAppInitialAsset !== AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET || config2.desktopVersion !== void 0 && config2.desktopVersion !== config2.auditedDesktopVersion && config2.desktopVersion !== CLIENT_OWNED_VOICE_VERSION)
+    if (config2.auditedDesktopVersion !== AUDITED_CPA_LIVE_VOICE_DESKTOP_VERSION || config2.auditedAppInitialAsset !== AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET || config2.desktopVersion !== void 0 && config2.desktopVersion !== config2.auditedDesktopVersion && !supportsVoiceVersion(CLIENT_OWNED_VOICE_ASSETS, config2.desktopVersion))
       return { status: "unsupported", dispose() {
       } };
     const importModule = options.importModule ?? ((url2) => import(url2));
@@ -43396,14 +44004,11 @@ ${usage_default}`;
       if (disposed) return;
       try {
         const names = loadedAssetNames(target.document, target.performance);
-        const clientOwned = auditedAppInitialAssetPresent(names, CLIENT_OWNED_VOICE_INITIAL_ASSET) && auditedAppInitialAssetPresent(names, CLIENT_OWNED_VOICE_SHARED_ASSET);
-        const legacy = auditedAppInitialAssetPresent(names, AUDITED_CPA_LIVE_VOICE_APP_INITIAL_ASSET) && auditedAppInitialAssetPresent(names, SHARED_ASSET);
-        if (clientOwned || legacy) {
-          module ??= await importModule(
-            `app://-/assets/${clientOwned ? CLIENT_OWNED_VOICE_SHARED_ASSET : SHARED_ASSET}`
-          );
+        const assets = selectVoiceAssets(LAUNCH_ASSETS, names, config2.desktopVersion);
+        if (assets) {
+          module ??= await importModule(`app://-/assets/${assets.shared}`);
           if (disposed) return;
-          const services = clientOwned ? module?.Kat : module?.fN;
+          const services = module?.[assets.services];
           if (isRecord16(services)) {
             const original = services.realtimeVoiceRuntime;
             if (typeof original === "function" || isRecord16(original)) {
@@ -43454,11 +44059,294 @@ ${usage_default}`;
     return handle;
   }
 
+  // src/renderer-voice-capability.ts
+  var GLOBAL = "__codexhostVoiceCapabilityV1";
+  var INFERENCE_GATE = "3683713372";
+  var record6 = (value) => value !== null && typeof value === "object";
+  var capable = (value) => record6(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 (record6(hook) && result.length < 4096 && !seen.has(hook)) {
+      seen.add(hook);
+      result.push(hook);
+      hook = hook.next;
+    }
+    return hook == null ? result : [];
+  }
+  function composerFibers(composer, chat = false) {
+    const fibers = /* @__PURE__ */ new Set();
+    const rootKey = Object.getOwnPropertyNames(composer).find(
+      (key) => key.startsWith("__reactFiber$")
+    );
+    const ancestors = rootKey ? committedReactAncestors(Object.getOwnPropertyDescriptor(composer, rootKey)?.value) : [];
+    let root = ancestors[0];
+    if (chat) {
+      const owners = ancestors.filter(
+        ({ memoizedProps: props }) => record6(props) && props.isWorkConversation === false && props.isTemporaryChat === false && props.shouldBlockExternalEgress === false && props.readOnly !== true && typeof props.conversationId === "string" && record6(props.composerSelectionContext) && props.composerSelectionContext.conversationId === props.conversationId
+      );
+      if (owners.length !== 1) return fibers;
+      root = owners[0];
+    }
+    if (!root) return fibers;
+    for (const element of [composer, ...composer.querySelectorAll("*")].slice(0, 2048)) {
+      const key = Object.getOwnPropertyNames(element).find((key2) => key2.startsWith("__reactFiber$"));
+      if (!key) continue;
+      const ancestors2 = committedReactAncestors(Object.getOwnPropertyDescriptor(element, key)?.value);
+      const boundary = ancestors2.indexOf(root);
+      if (boundary < 0) continue;
+      for (const fiber of ancestors2.slice(0, boundary + 1)) if (record6(fiber)) fibers.add(fiber);
+    }
+    return fibers;
+  }
+  function bindComposerVoiceCapability(composer, family, gates, allowed, chat = false) {
+    return bindVoiceCapabilitySubscriptions(
+      () => composerFibers(composer, chat),
+      family,
+      gates,
+      allowed
+    );
+  }
+  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 (!record6(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 (!record6(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 || !record6(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)
+          )
+        );
+      }
+    };
+  }
+  function installVoiceCapabilityProjection(options = {}) {
+    const target = options.target ?? globalThis;
+    if (target[GLOBAL]) return target[GLOBAL];
+    const config2 = readCpaLiveVoiceHookConfig(target);
+    if (!config2) return { status: "disabled", dispose() {
+    } };
+    if (!supportsVoiceVersion(CLIENT_OWNED_VOICE_ASSETS, config2.desktopVersion))
+      return { status: "unsupported", dispose() {
+      } };
+    let timer;
+    let binding;
+    let composer;
+    let disposed = false;
+    const handle = {
+      status: "pending",
+      dispose() {
+        disposed = true;
+        target.clearTimeout(timer);
+        binding?.dispose();
+        if (target[GLOBAL] === handle) Reflect.deleteProperty(target, GLOBAL);
+      }
+    };
+    target[GLOBAL] = handle;
+    const hookActive = (key) => {
+      const hook = target[key];
+      return record6(hook) && hook.status === "active";
+    };
+    const currentRoute = () => {
+      try {
+        const routing = target.__codexhostHostRoutingV1;
+        const route = routing?.forComposer();
+        return route?.hostId === "local" && routing?.forHost("local") === route ? route : void 0;
+      } catch {
+        return void 0;
+      }
+    };
+    const external = () => {
+      try {
+        return currentRoute()?.policy.selectedModel()?.startsWith("codexhost/") === true;
+      } catch {
+        return false;
+      }
+    };
+    const chatGateway = () => !isWorkComposerSurface(target) && chatLiveVoicePreferenceAllowsOverride(target);
+    const allowed = () => !!readCpaLiveVoiceHookConfig(target) && voiceGatewayIsReady(target) && hookActive("__codexhostClientOwnedVoiceV1") && hookActive("__codexhostExternalVoiceLaunchV1") && (chatGateway() || !!currentRoute() && (isWorkComposerSurface(target) || external() && target.document?.querySelectorAll("[data-chatgpt-composer]").length === 0) && (cpaLiveVoicePreferenceAllowsInstall(target) || external()));
+    const refresh = async () => {
+      if (disposed) return;
+      try {
+        const names = loadedAssetNames(target.document, target.performance);
+        const assets = selectVoiceAssets(CLIENT_OWNED_VOICE_ASSETS, names, config2.desktopVersion);
+        if (!assets) {
+          handle.status = "unsupported";
+        } else if (!allowed()) handle.status = "pending";
+        else {
+          const module = await (options.importModule ?? ((url2) => import(url2)))(
+            `app://-/assets/${assets.initial}`
+          );
+          if (disposed) return;
+          if (typeof module.njr !== "function")
+            throw new Error("Voice capability exports unavailable");
+          const composers = [
+            ...target.document?.querySelectorAll(
+              chatGateway() ? "[data-chatgpt-composer]" : "[data-codex-composer-root]"
+            ) ?? []
+          ].filter(
+            (element) => element.getBoundingClientRect().width > 0 && !element.closest("[hidden], [inert]")
+          );
+          if (composers.length !== 1) throw new Error("Voice composer unavailable");
+          if (composers[0] !== composer || !binding?.current()) {
+            module.njr();
+            binding?.dispose();
+            binding = void 0;
+            composer = composers[0];
+            binding = bindComposerVoiceCapability(
+              composer,
+              module.tjr,
+              module.uBr,
+              allowed,
+              chatGateway()
+            );
+          }
+          handle.status = "active";
+        }
+      } catch {
+        handle.status = "unsupported";
+      }
+      if (handle.status !== "active") {
+        binding?.dispose();
+        binding = void 0;
+        composer = void 0;
+      }
+      if (!disposed) timer = target.setTimeout(() => void refresh(), 1e3);
+    };
+    void refresh();
+    return handle;
+  }
+
   // src/production-entry.ts
   installCpaLiveVoiceHook();
   installClientOwnedVoiceHook();
   installExternalVoiceLaunchHook();
   installNativeChatVoiceHook();
+  installVoiceCapabilityProjection();
   var installBinding = () => {
     installRendererBinding();
   };