@karlorz/codexhost-cli-linux-arm64 0.13.3-7 → 0.14.0-1

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

@@ -14522,6 +14522,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 
   // ../shared-contracts/dist/delegation-read.js
   var REMOTE_THREAD_REPLY_MAX_BYTES = 16 * 1024 * 1024;
+  var THREAD_REFERENCE_SOURCE_HOST_PARAM = "codexhostSourceHostId";
   var delegationReadParamsSchema = external_exports.strictObject({
     threadId: external_exports.string().min(1).max(1024),
     view: external_exports.enum(["result", "messages"]),
@@ -14657,10 +14658,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var project = external_exports.string().min(1).max(4096);
   var usageStatisticsParamsSchema = external_exports.strictObject({
     range: external_exports.enum(USAGE_STATISTICS_RANGES),
+    /** Display timezone for ranges, dates and hourly buckets; omitted means the Host's local zone. */
+    timeZone: external_exports.string().min(1).max(128).refine((value) => {
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: value });
+        return true;
+      } catch {
+        return false;
+      }
+    }, "Unsupported usage statistics timezone").optional(),
     harness: harness.optional(),
     model: model.nullable().optional(),
     project: project.nullable().optional(),
-    /** One local date inside the range. */
+    /** One date in the query timezone inside the range. */
     date: localDate.optional()
   });
   var usageStatisticsTotalsSchema = external_exports.strictObject({
@@ -14696,7 +14706,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   });
   var usageStatisticsResultSchema = external_exports.strictObject({
     range: external_exports.enum(USAGE_STATISTICS_RANGES),
-    /** First local date of the range; null for all time. */
+    /** First date in the query timezone (Host local when omitted); null for all time. */
     from: localDate.nullable(),
     to: localDate,
     /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
@@ -14736,7 +14746,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     totals: usageStatisticsTotalsSchema,
     /** Each date and Harness of the range: every filter except the day. */
     daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
-    /** Local weekday (0 = Sunday) and hour, all filters applied. */
+    /** Weekday (0 = Sunday) and hour in the query timezone, all filters applied. */
     hourly: external_exports.array(external_exports.strictObject({
       weekday: external_exports.number().int().min(0).max(6),
       hour: external_exports.number().int().min(0).max(23),
@@ -14846,6 +14856,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "codexhost/harness/display-settings/set",
     "codexhost/harness/inspect",
     "codexhost/harness/installation",
+    "codexhost/harness/installation/start",
+    "codexhost/harness/installation/status",
     "codexhost/harness/launch-settings/get",
     "codexhost/harness/launch-settings/set",
     "codexhost/harness/grok-computer-use/get",
@@ -14923,7 +14935,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
   var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
   var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+  var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text) => text.length <= maximum));
+  var composerIndicatorsSchema = external_exports.array(external_exports.object({
+    kind: external_exports.literal("countdown"),
+    id: external_exports.string().min(1).max(64),
+    expiresAtUnix: nonNegativeSafeIntegerSchema,
+    label: indicatorTextSchema(256).optional(),
+    tooltip: indicatorTextSchema(1024).optional()
+  }).strict()).max(2).refine((entries) => new Set(entries.map(({ id }) => id)).size === entries.length, {
+    message: "Composer indicator IDs must be unique"
+  });
   var threadUsageSnapshotSchema = external_exports.object({
+    composerIndicators: composerIndicatorsSchema.optional(),
     inputTokens: nonNegativeSafeIntegerSchema.optional(),
     cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
     cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15331,7 +15354,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }).strict().optional(),
     autonomousTurns: external_exports.object({
       observe: external_exports.boolean()
-    }).strict().optional()
+    }).strict().optional(),
+    /** True only when `turn.steer` delivers input into the active Turn through a native primitive. */
+    steer: external_exports.boolean().optional()
   }).strict();
   var harnessConfigurationStateSchema = external_exports.object({
     effectiveModel: harnessModelRefSchema.optional(),
@@ -15463,6 +15488,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       seen.add(thread.threadId);
     }
   });
+  var threadSteeringInspectParamsSchema = external_exports.object({
+    threadId: hostThreadIdSchema,
+    /** The text about to be steered; a Harness command always stops and restarts. */
+    text: external_exports.string().optional()
+  }).strict();
+  var THREAD_STEER_DELIVERY_PARAM = "codexhostSteerDelivery";
+  var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
+  var threadSteeringInspectResultSchema = external_exports.object({
+    delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
+  }).strict();
 
   // ../shared-contracts/dist/harness-plugins.js
   var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
@@ -15584,6 +15619,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     latestVersion: external_exports.string().min(1).max(128),
     updateAvailable: external_exports.boolean(),
     canUpdate: external_exports.boolean(),
+    /** Defaults to CLI; some Harnesses ship only inside a desktop application. */
+    versionKind: external_exports.enum(["cli", "application"]).optional(),
+    /** Official download opened by the user; does not imply an automatic installation. */
+    manualUpdateUrl: external_exports.url().max(2048).refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Manual updates require a credential-free HTTPS URL").optional(),
     // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
     message: external_exports.string().max(2048).optional(),
     messageCode: external_exports.string().min(1).max(128).optional(),
@@ -15591,6 +15630,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     notice: harnessLocalizedTextSchema.optional(),
     latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
   }).strict();
+  var harnessInstallationTaskParamsSchema = external_exports.object({ taskId: external_exports.string().uuid() }).strict();
+  var harnessInstallationTaskSchema = external_exports.discriminatedUnion("status", [
+    external_exports.object({ taskId: external_exports.string().uuid(), status: external_exports.literal("running") }).strict(),
+    external_exports.object({
+      taskId: external_exports.string().uuid(),
+      status: external_exports.literal("succeeded"),
+      result: harnessInstallationStateSchema
+    }).strict(),
+    external_exports.object({
+      taskId: external_exports.string().uuid(),
+      status: external_exports.literal("failed"),
+      error: external_exports.object({ code: external_exports.number().int(), message: external_exports.string().min(1).max(2048) }).strict()
+    }).strict()
+  ]);
 
   // ../shared-contracts/dist/codex-accounts.js
   var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -16099,13 +16152,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   function resourceNamesFromPerformance(source) {
     const target = source ?? (typeof performance === "undefined" ? void 0 : performance);
-    if (!target || typeof target.getEntriesByType !== "function") return [];
-    return target.getEntriesByType("resource").map((entry) => entry.name).filter((name) => typeof name === "string");
+    if (!target) return [];
+    const names = [];
+    const push = (name) => {
+      if (typeof name === "string" && name) names.push(name);
+    };
+    if (typeof target.getEntries === "function") {
+      for (const entry of target.getEntries()) push(entry.name);
+    } else if (typeof target.getEntriesByType === "function") {
+      for (const entry of target.getEntriesByType("resource")) push(entry.name);
+    }
+    return names;
   }
   function loadedAssetNames(root, performanceSource) {
     const names = resourceNamesFromPerformance(performanceSource);
     if (!root || !("querySelectorAll" in root)) return names;
-    for (const element of root.querySelectorAll("script[src], link[href]")) {
+    for (const element of root.querySelectorAll(
+      'script[src], link[href], link[rel="modulepreload"], link[rel="preload"]'
+    )) {
       const value = element.getAttribute("src") ?? element.getAttribute("href");
       if (value) names.push(value);
     }
@@ -16203,8 +16267,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const present = profiles.filter(
       (profile2) => [profile2.initial, profile2.shared].some((asset) => auditedAppInitialAssetPresent(names, asset))
     );
+    if (version2 !== void 0) {
+      const profile2 = profiles.find((entry) => entry.version === version2);
+      if (!profile2) return void 0;
+      if (present.some((entry) => entry.version !== version2)) return void 0;
+      const complete = [profile2.initial, profile2.shared].every(
+        (asset) => auditedAppInitialAssetPresent(names, asset)
+      );
+      return complete || present.length === 0 ? profile2 : void 0;
+    }
     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;
+    return profile && [profile.initial, profile.shared].every((asset) => auditedAppInitialAssetPresent(names, asset)) ? profile : void 0;
   }
 
   // src/renderer-chat-voice-debug.ts
@@ -16228,28 +16301,54 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var RENDERER_NEW_THREAD_PREFERENCE_KEY = "codexhost.new-thread-preference.v1";
 
   // src/renderer-client-owned-voice.ts
-  var CLIENT_OWNED_VOICE_VERSION = "26.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_VERSION = "26.1021.31345";
+  var CLIENT_OWNED_VOICE_INITIAL_ASSET = "app-initial-feb30b196d11.js";
+  var CLIENT_OWNED_VOICE_SHARED_ASSET = "app-shared-2cae01273bae.js";
+  var CLIENT_OWNED_VOICE_OVERLAY_ASSET = "avatar-overlay-native-page-d549db3706f1.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
+      overlay: CLIENT_OWNED_VOICE_OVERLAY_ASSET,
+      fetch: "Htr",
+      fetchFrom: "initial",
+      bridge: "bIt",
+      services: "Qot",
+      capabilityInit: "l0n",
+      capabilityFamily: "c0n",
+      inferenceGateFamily: "Cnr"
+    },
+    {
+      version: "26.1016.62342",
+      initial: "app-initial-dddef47d6ef6.js",
+      shared: "app-shared-fc3316d48427.js",
+      overlay: "avatar-overlay-native-page-ef8332c6a2fb.js",
+      init: "Oit",
+      fetch: "Eit",
+      bridge: "AFt",
+      responseError: "Mit",
+      services: "ist",
+      capabilityInit: "njr",
+      capabilityFamily: "tjr",
+      inferenceGateFamily: "uBr"
     },
     {
       version: "26.1016.61520",
       initial: "app-initial-c95ddb62696e.js",
       shared: "app-shared-2eda13eb7044.js",
-      overlay: "avatar-overlay-native-page-fcc17283519a.js"
+      overlay: "avatar-overlay-native-page-fcc17283519a.js",
+      init: "Oit",
+      fetch: "Eit",
+      bridge: "AFt",
+      responseError: "Mit",
+      services: "ist",
+      capabilityInit: "njr",
+      capabilityFamily: "tjr",
+      inferenceGateFamily: "uBr"
     }
   ];
   var SHARED_INIT = "Oit";
-  var SHARED_FETCH = "Eit";
-  var SHARED_BRIDGE = "AFt";
   var SHARED_RESPONSE_ERROR = "Mit";
   var HOOK_GLOBAL = "__codexhostClientOwnedVoiceV1";
   function object2(value) {
@@ -16360,7 +16459,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var lastVoiceProductExperience;
   function rememberVoiceProductExperience(request) {
     const experience = object2(request) ? request.productExperience : void 0;
-    lastVoiceProductExperience = experience === "chat" || experience === "work" ? experience : void 0;
+    lastVoiceProductExperience = experience === "chat" || experience === "work" || experience === "codex" ? experience : void 0;
   }
   function lastVoiceLaunchProductExperience() {
     return lastVoiceProductExperience;
@@ -16386,7 +16485,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const experience = lastVoiceLaunchProductExperience();
       const chat = experience === "chat";
       const model2 = backendModelName(options.headers);
-      const work = !chat && (experience === "work" || isWorkBackendModel(model2) || workSurface());
+      const work = !chat && (experience === "work" || experience === "codex" || isWorkBackendModel(model2) || workSurface());
       const external = !chat && (model2.startsWith("codexhost/") || externalHarness());
       const gateway = external || (work ? workOverride() : chatOverride());
       chatVoiceDebug("wham-create", {
@@ -16478,33 +16577,44 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const assets = selectVoiceAssets(CLIENT_OWNED_VOICE_ASSETS, names, config2.desktopVersion);
       if (assets) {
         try {
-          const module = await importModule(`app://-/assets/${assets.shared}`);
+          const sharedModule = await importModule(`app://-/assets/${assets.shared}`);
+          const fetchFrom = "fetchFrom" in assets ? assets.fetchFrom : "shared";
+          const fetchModule = fetchFrom === "initial" ? await importModule(`app://-/assets/${assets.initial}`) : sharedModule;
           if (disposed) return;
-          if (typeof module[SHARED_INIT] !== "function") throw new Error();
-          module[SHARED_INIT]();
-          const fetchClass = module[SHARED_FETCH];
-          const bridgeClass = module[SHARED_BRIDGE];
+          const init = "init" in assets ? assets.init : SHARED_INIT;
+          const fetchName = assets.fetch;
+          const bridgeName = assets.bridge;
+          const errorName = "responseError" in assets ? assets.responseError : SHARED_RESPONSE_ERROR;
+          if (typeof init === "string" && typeof fetchModule[init] === "function") {
+            fetchModule[init]();
+          } else if (typeof init === "string" && typeof sharedModule[init] === "function") {
+            sharedModule[init]();
+          }
+          const fetchClass = typeof fetchName === "string" ? fetchModule[fetchName] : void 0;
+          const bridgeClass = typeof bridgeName === "string" ? sharedModule[bridgeName] : void 0;
           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")
+          const responseError = typeof errorName === "string" && typeof sharedModule[errorName] === "function" ? sharedModule[errorName] : async (response) => {
+            throw Object.assign(new Error(await response.text()), { status: response.status });
+          };
+          if (typeof client?.fetch !== "function" || typeof bridge?.dispatchMessage !== "function" || typeof bridge?.subscribe !== "function")
             throw new Error();
           restore = wrapClientOwnedVoiceFetch(
             client,
             bridge,
             () => cpaLiveVoicePreferenceAllowsInstall(target),
-            module[SHARED_RESPONSE_ERROR],
+            responseError,
             () => chatLiveVoicePreferenceAllowsOverride(target),
             () => isWorkComposerSurface(target),
             () => isExternalHarnessComposer(target)
           );
           handle.status = "active";
         } catch {
-          handle.status = "unsupported";
         }
-        return;
       }
+      if (handle.status === "active") return;
       if (Date.now() - started >= 6e4) {
         handle.status = "unsupported";
         return;
@@ -16515,73 +16625,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return handle;
   }
 
-  // src/renderer-overlay-thread-isolation.ts
-  function isRecord2(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-  }
-  var BLOCKED_METHODS = /* @__PURE__ */ new Set(["thread/started"]);
-  function isAvatarOverlayHref(href) {
-    try {
-      const url2 = new URL(href);
-      if (url2.pathname === "/avatar-overlay.html") return true;
-      return url2.searchParams.get("initialRoute") === "/avatar-overlay";
-    } catch {
-      return false;
-    }
-  }
-  function overlayBlocksHostNotification(method, threadId, allowedRealtimeThreadIds) {
-    if (method.startsWith("thread/realtime/")) {
-      return false;
-    }
-    if (threadId !== void 0 && allowedRealtimeThreadIds.has(threadId)) {
-      return false;
-    }
-    if (BLOCKED_METHODS.has(method)) return true;
-    return method.startsWith("turn/") || method.startsWith("item/");
-  }
-  function notificationThreadId(params) {
-    if (!isRecord2(params)) return void 0;
-    if (typeof params.threadId === "string" && params.threadId.length > 0) return params.threadId;
-    const thread = params.thread;
-    if (isRecord2(thread) && typeof thread.id === "string" && thread.id.length > 0) {
-      return thread.id;
-    }
-    return void 0;
-  }
-  function installOverlayThreadIsolation(target = typeof globalThis === "undefined" ? null : globalThis) {
-    if (!target || typeof target.addEventListener !== "function") {
-      return { status: "disabled", dispose() {
-      } };
-    }
-    const href = target.location?.href;
-    if (typeof href !== "string" || !isAvatarOverlayHref(href)) {
-      return { status: "disabled", dispose() {
-      } };
-    }
-    const voiceThreadIds = /* @__PURE__ */ new Set();
-    const listener = (event) => {
-      const message = event.data;
-      if (!isRecord2(message) || message.type !== "mcp-notification") return;
-      if (typeof message.method !== "string") return;
-      const threadId = notificationThreadId(message.params);
-      if (message.method === "thread/realtime/started" && threadId) {
-        voiceThreadIds.add(threadId);
-        return;
-      }
-      if (overlayBlocksHostNotification(message.method, threadId, voiceThreadIds)) {
-        event.stopImmediatePropagation();
-      }
-      if (message.method === "thread/deleted" && threadId) voiceThreadIds.delete(threadId);
-    };
-    target.addEventListener("message", listener, true);
-    return {
-      status: "active",
-      dispose() {
-        target.removeEventListener("message", listener, true);
-      }
-    };
-  }
-
   // ../desktop-control/dist/renderer-react-ownership.js
   function committedReactAncestors(value) {
     const MAX_VISITED_FIBERS = 2e5;
@@ -16662,6 +16705,553 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return stack.length > 0 ? exhausted() : [];
   }
 
+  // src/renderer-external-queue.ts
+  function isRecord2(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  function installRendererExternalQueue(target) {
+    if (!isRecord2(target) || typeof target.getTurnCoordinator !== "function" || typeof target.getConversation !== "function") {
+      return null;
+    }
+    if (typeof target.getStreamRole === "function") return null;
+    const coordinator = target.getTurnCoordinator();
+    const queue = isRecord2(coordinator) ? coordinator.serverQueue : null;
+    if (!isRecord2(queue) || typeof queue.isEnabled !== "function") return null;
+    const descriptor = Object.getOwnPropertyDescriptor(queue, "isEnabled");
+    if (!descriptor?.writable) return null;
+    const original = queue.isEnabled;
+    const getConversation = target.getConversation;
+    const isEnabled = (...args) => {
+      const threadId = args[0];
+      if (typeof threadId === "string") {
+        const conversation = getConversation.call(target, threadId);
+        if (isRecord2(conversation) && conversation.id === threadId && // Reserved transport marker from externalThreadValue, retained by
+        // Desktop in both newly created and hydrated conversation metadata.
+        conversation.modelProvider === "codexhost") {
+          return false;
+        }
+      }
+      return original.apply(queue, args);
+    };
+    queue.isEnabled = isEnabled;
+    return () => {
+      if (queue.isEnabled === isEnabled) Object.defineProperty(queue, "isEnabled", descriptor);
+    };
+  }
+
+  // src/renderer-native-thread.ts
+  function isRecord3(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  async function verifyNativeCodexThread(sendRequest, threadId) {
+    const native = await sendRequest("thread/read", { threadId, includeTurns: false });
+    const thread = isRecord3(native) ? native.thread : null;
+    if (!isRecord3(thread) || thread.id !== threadId || typeof thread.modelProvider !== "string" || !thread.modelProvider || thread.modelProvider === "codexhost" || typeof thread.cliVersion !== "string" || !thread.cliVersion || thread.cliVersion === "codexhost") {
+      throw new Error("Native Thread response cannot establish Codex ownership");
+    }
+  }
+
+  // src/renderer-request-sender.ts
+  function isUnsupportedMethod(error51, method) {
+    if (typeof error51 !== "object" || error51 === null) return false;
+    const code = "code" in error51 ? error51.code : void 0;
+    const message = "message" in error51 ? error51.message : void 0;
+    return code === -32601 || code === -32600 && typeof message === "string" && message.startsWith(`Invalid request: unknown variant \`${method}\``);
+  }
+
+  // src/renderer-external-steering.ts
+  var THREAD_STEERING_INSPECT_METHOD = "codexhost/thread/steering/inspect";
+  var THREAD_OWNERSHIP_LIST_METHOD = "codexhost/thread/ownership/list";
+  function isRecord4(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  function isManager(value) {
+    return isRecord4(value) && ["sendRequest", "steerTurn", "startTurn", "getTurnCoordinator"].every(
+      (key) => typeof value[key] === "function"
+    );
+  }
+  function inputText(input) {
+    if (!Array.isArray(input)) return "";
+    return input.filter(
+      (item) => isRecord4(item) && typeof item.text === "string"
+    ).map((item) => item.text).join("\n");
+  }
+  function queuedFollowUpText(message) {
+    if (!isRecord4(message)) return "";
+    if (typeof message.text === "string" && message.text.trim()) return message.text;
+    const context = message.context;
+    if (isRecord4(context) && typeof context.prompt === "string" && context.prompt.trim()) {
+      return context.prompt;
+    }
+    return "";
+  }
+  function restoreQueuedTurnStartText(manager, params) {
+    if (!isManager(manager) || !isRecord4(params) || typeof params.threadId !== "string")
+      return params;
+    if (inputText(params.input).trim()) return params;
+    const messageId = params.clientUserMessageId;
+    if (typeof messageId !== "string" || !messageId) return params;
+    const coordinator = manager.getTurnCoordinator();
+    if (!isRecord4(coordinator) || typeof coordinator.readMessages !== "function") return params;
+    const messages = coordinator.readMessages.call(coordinator, params.threadId);
+    if (!Array.isArray(messages)) return params;
+    const match = messages.find((message) => isRecord4(message) && message.id === messageId);
+    const text = queuedFollowUpText(match);
+    if (!text) return params;
+    return { ...params, input: [{ type: "text", text, text_elements: [] }] };
+  }
+  function submissionHost(manager) {
+    const coordinator = manager.getTurnCoordinator();
+    const options = isRecord4(coordinator) ? coordinator.options : null;
+    const host = isRecord4(options) ? options.submissionHost : null;
+    if (!isRecord4(host) || typeof host.getActiveTurnId !== "function" || typeof host.hasPendingTurnStart !== "function") {
+      throw new Error("Desktop turn submission binding is unavailable");
+    }
+    return {
+      getActiveTurnId: (threadId) => host.getActiveTurnId.call(host, threadId),
+      hasPendingTurnStart: (threadId) => host.hasPendingTurnStart.call(host, threadId)
+    };
+  }
+  function installSteeringMethods(manager, replacements) {
+    const originalPrototype = Object.getPrototypeOf(manager);
+    const overrides = Object.create(originalPrototype);
+    const names = Object.keys(replacements).filter(
+      (name) => typeof replacements[name] === "function"
+    );
+    const descriptors = new Map(
+      names.map((name) => [name, Object.getOwnPropertyDescriptor(manager, name)])
+    );
+    for (const name of names) {
+      const own = descriptors.get(name);
+      Object.defineProperty(own ? manager : overrides, name, {
+        configurable: own?.configurable ?? true,
+        enumerable: own?.enumerable ?? false,
+        writable: true,
+        value: replacements[name]
+      });
+    }
+    if (names.some((name) => !descriptors.get(name))) {
+      Object.setPrototypeOf(manager, overrides);
+    }
+    return (name) => {
+      const own = descriptors.get(name);
+      const holder = own ? manager : overrides;
+      if (Reflect.get(holder, name) === replacements[name]) {
+        if (own) Object.defineProperty(manager, name, own);
+        else Reflect.deleteProperty(overrides, name);
+      }
+      if (Object.getPrototypeOf(manager) === overrides && names.every((key) => !Object.hasOwn(overrides, key))) {
+        Object.setPrototypeOf(manager, originalPrototype);
+      }
+    };
+  }
+  var INTERRUPTED_QUEUE_REASON = "Interrupted before the steer was accepted.";
+  async function preserveQueuedFollowUps(manager, threadId) {
+    const coordinator = manager.getTurnCoordinator();
+    if (!isRecord4(coordinator) || typeof coordinator.loadMessages !== "function" || typeof coordinator.readMessages !== "function" || typeof coordinator.mutate !== "function") {
+      throw new Error("Desktop follow-up queue binding is unavailable");
+    }
+    await coordinator.loadMessages.call(coordinator, threadId);
+    const messages = coordinator.readMessages.call(coordinator, threadId);
+    if (!Array.isArray(messages)) throw new Error("Desktop follow-up queue is unavailable");
+    const alreadyPaused = new Set(
+      messages.filter((message) => isRecord4(message) && message.pausedReason != null).map((message) => message.id)
+    );
+    return () => {
+      coordinator.mutate.call(coordinator, threadId, (current) => {
+        if (!Array.isArray(current)) return current;
+        return current.map((message) => {
+          if (!isRecord4(message) || alreadyPaused.has(message.id) || message.pausedReason !== INTERRUPTED_QUEUE_REASON)
+            return message;
+          const resumed = { ...message };
+          delete resumed.pausedReason;
+          return resumed;
+        });
+      });
+    };
+  }
+  function installRendererExternalSteering(target, sendTurnStart, prepareTurnInput) {
+    if (!isManager(target)) return null;
+    const manager = target;
+    const originalSteer = manager.steerTurn;
+    const originalSend = manager.sendRequest;
+    const routes = /* @__PURE__ */ new Map();
+    const activeTurnSteers = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Map();
+    let disposed = false;
+    const send = function(method, params, options) {
+      if ((method === "turn/start" || method === "turn/steer") && prepareTurnInput) {
+        params = prepareTurnInput(params);
+      }
+      if (method === "turn/start") params = restoreQueuedTurnStartText(manager, params);
+      const messageId = isRecord4(params) ? params.clientUserMessageId : null;
+      const route = typeof messageId === "string" && isRecord4(params) ? routes.get(`${params.threadId}\0${messageId}`) : void 0;
+      if (method !== "turn/start" || !isRecord4(params) || !route || route.threadId !== params.threadId) {
+        if (method === "turn/start" && sendTurnStart) {
+          return sendTurnStart(params, (input) => {
+            if (disposed) throw new Error("External submission binding was disposed");
+            return originalSend.call(manager, method, input, options);
+          });
+        }
+        if (method === "turn/steer" && isRecord4(params) && typeof params.threadId === "string" && activeTurnSteers.has(params.threadId)) {
+          params = { ...params, [THREAD_STEER_DELIVERY_PARAM]: "activeTurn" };
+        }
+        return originalSend.call(manager, method, params, options);
+      }
+      if (disposed) return Promise.reject(new Error("External steering binding was disposed"));
+      return Promise.resolve(
+        originalSend.call(
+          manager,
+          "turn/steer",
+          {
+            threadId: route.threadId,
+            expectedTurnId: route.expectedTurnId,
+            clientUserMessageId: messageId,
+            input: params.input,
+            additionalContext: params.additionalContext,
+            responsesapiClientMetadata: params.responsesapiClientMetadata,
+            ...params[THREAD_REFERENCE_SOURCE_HOST_PARAM] !== void 0 ? { [THREAD_REFERENCE_SOURCE_HOST_PARAM]: params[THREAD_REFERENCE_SOURCE_HOST_PARAM] } : {},
+            [THREAD_STEER_DELIVERY_PARAM]: "newTurn"
+          },
+          options
+        )
+      ).then((response) => {
+        if (!isRecord4(response) || typeof response.turnId !== "string" || !response.turnId) {
+          throw new Error("External steering returned no replacement Turn identity");
+        }
+        return {
+          turn: {
+            id: response.turnId,
+            status: "inProgress",
+            items: [],
+            error: null,
+            startedAt: null,
+            completedAt: null,
+            durationMs: null,
+            itemsView: "full"
+          }
+        };
+      });
+    };
+    const inspectDelivery = async (threadId, text) => {
+      try {
+        const response = await originalSend.call(manager, THREAD_STEERING_INSPECT_METHOD, {
+          threadId,
+          ...text !== void 0 ? { text } : {}
+        });
+        return threadSteeringInspectResultSchema.parse(response).delivery;
+      } catch (error51) {
+        if (!isUnsupportedMethod(error51, THREAD_STEERING_INSPECT_METHOD)) throw error51;
+      }
+      let ownershipResponse;
+      try {
+        ownershipResponse = await originalSend.call(manager, THREAD_OWNERSHIP_LIST_METHOD, {
+          threadIds: [threadId]
+        });
+      } catch (error51) {
+        if (!isUnsupportedMethod(error51, THREAD_OWNERSHIP_LIST_METHOD)) throw error51;
+        await verifyNativeCodexThread(
+          (method, params) => originalSend.call(manager, method, params),
+          threadId
+        );
+        return "official";
+      }
+      const ownership = threadOwnershipListResultSchema.parse(ownershipResponse);
+      const owner = ownership.threads.find((thread) => thread.threadId === threadId)?.owner;
+      if (!owner) throw new Error("Thread ownership could not be resolved for steering");
+      return owner === "codex" ? "official" : "newTurn";
+    };
+    const steer = async function(...args) {
+      const [
+        threadId,
+        input,
+        restoreMessage,
+        serviceTier,
+        attachments,
+        clientUserMessageId,
+        additionalContext,
+        toolOutput,
+        onMessageAdded
+      ] = args;
+      if (typeof threadId !== "string") return originalSteer.apply(manager, args);
+      const role = manager.getStreamRole?.(threadId);
+      if (isRecord4(role) && role.role === "follower") return originalSteer.apply(manager, args);
+      let host = null;
+      let expectedTurnId;
+      try {
+        host = submissionHost(manager);
+        expectedTurnId = host.getActiveTurnId(threadId);
+      } catch {
+      }
+      const text = Array.isArray(input) ? inputText(input) : void 0;
+      const delivery = await inspectDelivery(threadId, text);
+      if (disposed) throw new Error("External steering binding was disposed");
+      if (delivery === "official") return originalSteer.apply(manager, args);
+      if (delivery === "activeTurn") {
+        activeTurnSteers.set(threadId, (activeTurnSteers.get(threadId) ?? 0) + 1);
+        try {
+          return await originalSteer.apply(manager, args);
+        } finally {
+          const remaining = (activeTurnSteers.get(threadId) ?? 1) - 1;
+          if (remaining > 0) activeTurnSteers.set(threadId, remaining);
+          else activeTurnSteers.delete(threadId);
+        }
+      }
+      if (!host) throw new Error("Desktop turn submission binding is unavailable");
+      const currentRole = manager.getStreamRole?.(threadId);
+      if (isRecord4(currentRole) && currentRole.role === "follower")
+        return originalSteer.apply(manager, args);
+      if (!Array.isArray(input) || input.length === 0 || input.some(
+        (item) => !isRecord4(item) || item.type !== "text" || typeof item.text !== "string"
+      ) || !input.some((item) => isRecord4(item) && typeof item.text === "string" && item.text.trim())) {
+        throw new Error("External steering requires non-empty text input");
+      }
+      if (toolOutput != null) throw new Error("External steering cannot replace a tool response");
+      if (!isRecord4(restoreMessage) || !isRecord4(restoreMessage.context)) {
+        throw new Error("Desktop steering message context is unavailable");
+      }
+      const messageId = typeof clientUserMessageId === "string" && clientUserMessageId ? clientUserMessageId : typeof restoreMessage.id === "string" && restoreMessage.id ? restoreMessage.id : crypto.randomUUID();
+      const fingerprint = JSON.stringify(input);
+      const existing = pending.get(threadId);
+      if (existing) {
+        if (existing.messageId === messageId && existing.fingerprint === fingerprint)
+          return existing.promise;
+        throw new Error("This Thread is already changing direction");
+      }
+      if (expectedTurnId != null && (typeof expectedTurnId !== "string" || !expectedTurnId)) {
+        throw new Error("Desktop active Turn identity is invalid");
+      }
+      if (expectedTurnId == null && host.hasPendingTurnStart(threadId)) {
+        throw new Error("Previous Turn submission has not been confirmed yet");
+      }
+      const context = restoreMessage.context;
+      const routeKey = `${threadId}\0${messageId}`;
+      if (typeof expectedTurnId === "string") routes.set(routeKey, { threadId, expectedTurnId });
+      const promise2 = Promise.resolve().then(async () => {
+        if (disposed) throw new Error("External steering binding was disposed");
+        const resumeQueue = await preserveQueuedFollowUps(manager, threadId);
+        if (disposed) throw new Error("External steering binding was disposed");
+        const response = await manager.startTurn(
+          threadId,
+          {
+            request: {
+              threadId,
+              input,
+              clientUserMessageId: messageId,
+              additionalContext,
+              responsesapiClientMetadata: restoreMessage.responsesapiClientMetadata,
+              cwd: restoreMessage.cwd,
+              serviceTier,
+              model: null,
+              effort: null,
+              collaborationMode: context.collaborationMode ?? null
+            },
+            context: {
+              attachments: attachments ?? [],
+              commentAttachments: context.commentAttachments ?? [],
+              mcpAppModelContextAttachments: context.mcpAppModelContextAttachments,
+              useAppServerPermissionDefault: true
+            }
+          },
+          onMessageAdded
+        );
+        if (!isRecord4(response) || !isRecord4(response.turn) || typeof response.turn.id !== "string") {
+          throw new Error("Desktop returned no replacement Turn identity");
+        }
+        try {
+          resumeQueue();
+        } catch {
+          console.error("codexhost could not restore follow-up queue state after steering");
+        }
+        return { turnId: response.turn.id };
+      }).finally(() => {
+        routes.delete(routeKey);
+        pending.delete(threadId);
+      });
+      pending.set(threadId, { messageId, fingerprint, promise: promise2 });
+      return promise2;
+    };
+    const originalRole = manager.getStreamRole;
+    const getStreamRole = typeof originalRole === "function" ? (...args) => {
+      const threadId = args[0];
+      if (typeof threadId === "string" && typeof manager.getConversation === "function") {
+        const conversation = manager.getConversation(threadId);
+        if (isRecord4(conversation) && conversation.id === threadId && conversation.modelProvider === "codexhost") {
+          return { role: "owner" };
+        }
+      }
+      return originalRole.apply(manager, args);
+    } : void 0;
+    const restoreMethod = installSteeringMethods(manager, {
+      sendRequest: send,
+      steerTurn: steer,
+      ...getStreamRole ? { getStreamRole } : {}
+    });
+    return () => {
+      disposed = true;
+      restoreMethod("steerTurn");
+      if (getStreamRole) restoreMethod("getStreamRole");
+      if (pending.size === 0) {
+        restoreMethod("sendRequest");
+      } else {
+        void Promise.allSettled([...pending.values()].map(({ promise: promise2 }) => promise2)).then(() => {
+          restoreMethod("sendRequest");
+        });
+      }
+    };
+  }
+
+  // src/renderer-overlay-thread-isolation.ts
+  function isRecord5(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  var BLOCKED_METHODS = /* @__PURE__ */ new Set(["thread/started"]);
+  function isAvatarOverlayHref(href) {
+    try {
+      const url2 = new URL(href);
+      if (url2.pathname === "/avatar-overlay.html") return true;
+      return url2.searchParams.get("initialRoute") === "/avatar-overlay";
+    } catch {
+      return false;
+    }
+  }
+  function overlayBlocksHostNotification(method, threadId, allowedRealtimeThreadIds) {
+    if (method.startsWith("thread/realtime/")) {
+      return false;
+    }
+    if (threadId !== void 0 && allowedRealtimeThreadIds.has(threadId)) {
+      return false;
+    }
+    if (BLOCKED_METHODS.has(method)) return true;
+    return method.startsWith("turn/") || method.startsWith("item/");
+  }
+  function notificationThreadId(params) {
+    if (!isRecord5(params)) return void 0;
+    if (typeof params.threadId === "string" && params.threadId.length > 0) return params.threadId;
+    const thread = params.thread;
+    if (isRecord5(thread) && typeof thread.id === "string" && thread.id.length > 0) {
+      return thread.id;
+    }
+    return void 0;
+  }
+  function installOverlayThreadIsolation(target = typeof globalThis === "undefined" ? null : globalThis) {
+    if (!target || typeof target.addEventListener !== "function") {
+      return { status: "disabled", dispose() {
+      } };
+    }
+    const href = target.location?.href;
+    if (typeof href !== "string" || !isAvatarOverlayHref(href)) {
+      return { status: "disabled", dispose() {
+      } };
+    }
+    const voiceThreadIds = /* @__PURE__ */ new Set();
+    const listener = (event) => {
+      const message = event.data;
+      if (!isRecord5(message) || message.type !== "mcp-notification") return;
+      if (typeof message.method !== "string") return;
+      const threadId = notificationThreadId(message.params);
+      if (message.method === "thread/realtime/started" && threadId) {
+        voiceThreadIds.add(threadId);
+        return;
+      }
+      if (overlayBlocksHostNotification(message.method, threadId, voiceThreadIds)) {
+        event.stopImmediatePropagation();
+      }
+      if (message.method === "thread/deleted" && threadId) voiceThreadIds.delete(threadId);
+    };
+    target.addEventListener("message", listener, true);
+    return {
+      status: "active",
+      dispose() {
+        target.removeEventListener("message", listener, true);
+      }
+    };
+  }
+
+  // src/renderer-overlay-external-followups.ts
+  var DISCOVERY_MS = 6e4;
+  var INTERVAL_MS = 50;
+  var HOOK_WALK_LIMIT = 120;
+  function isRecord6(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  function isFollowUpManager(value) {
+    return isRecord6(value) && ["sendRequest", "steerTurn", "startTurn", "getTurnCoordinator", "getConversation"].every(
+      (key) => typeof value[key] === "function"
+    );
+  }
+  function managerFromHookState(value) {
+    if (isFollowUpManager(value)) return value;
+    return isRecord6(value) && isFollowUpManager(value.manager) ? value.manager : null;
+  }
+  function overlayFollowUpManagers(document) {
+    const managers = /* @__PURE__ */ new Set();
+    const surfaces = [...document.querySelectorAll("[data-avatar-overlay-native-surface-id]")];
+    const roots = surfaces.length > 0 ? surfaces : [document.documentElement];
+    for (const element of roots) {
+      const key = Object.getOwnPropertyNames(element).find(
+        (name) => name.startsWith("__reactFiber$")
+      );
+      const fiber = key ? Object.getOwnPropertyDescriptor(element, key)?.value : void 0;
+      for (const current of committedReactAncestors(fiber)) {
+        let hook = current.memoizedState;
+        for (let index = 0; hook && index < HOOK_WALK_LIMIT; index += 1) {
+          const manager = managerFromHookState(hook.memoizedState);
+          if (manager) managers.add(manager);
+          hook = hook.next && typeof hook.next === "object" ? hook.next : null;
+        }
+      }
+    }
+    return [...managers];
+  }
+  function installOverlayExternalFollowUps(target = typeof globalThis === "undefined" ? null : globalThis) {
+    const href = target?.location?.href;
+    if (!target || typeof href !== "string" || !isAvatarOverlayHref(href)) {
+      return { status: "disabled", dispose() {
+      } };
+    }
+    const wrapped = /* @__PURE__ */ new WeakSet();
+    const cleanups = /* @__PURE__ */ new Set();
+    let disposed = false;
+    let timer;
+    const started = Date.now();
+    const handle = {
+      status: "pending",
+      dispose() {
+        disposed = true;
+        if (timer !== void 0) target.clearTimeout(timer);
+        for (const cleanup of cleanups) {
+          try {
+            cleanup();
+          } catch {
+          }
+        }
+        cleanups.clear();
+      }
+    };
+    const attempt = () => {
+      if (disposed) return;
+      const document = target.document;
+      if (document) {
+        for (const manager of overlayFollowUpManagers(document)) {
+          if (wrapped.has(manager)) continue;
+          const queue = installRendererExternalQueue(manager);
+          const steering = installRendererExternalSteering(manager);
+          if (!queue && !steering) continue;
+          wrapped.add(manager);
+          if (queue) cleanups.add(queue);
+          if (steering) cleanups.add(steering);
+          handle.status = "active";
+        }
+      }
+      if (disposed || handle.status === "active") return;
+      if (Date.now() - started >= DISCOVERY_MS) return;
+      timer = target.setTimeout(attempt, INTERVAL_MS);
+    };
+    attempt();
+    return handle;
+  }
+
   // src/renderer-voice-capability.ts
   var INFERENCE_GATE = "3683713372";
   var record2 = (value) => value !== null && typeof value === "object";
@@ -16702,6 +17292,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return null;
     }
   }
+  function isFamily(value) {
+    return record2(value) && record2(value.scope) && typeof value.resolve === "function";
+  }
+  function initializeVoiceCapabilityFamilies(module, assets) {
+    const initialize = module[assets.capabilityInit];
+    if (typeof initialize !== "function") throw new Error("Voice capability initializer unavailable");
+    initialize();
+    const family = module[assets.capabilityFamily];
+    const gates = module[assets.inferenceGateFamily];
+    if (!isFamily(family) || !isFamily(gates))
+      throw new Error("Voice capability families unavailable");
+    return { family, gates };
+  }
   function hooks(fiber) {
     const result = [];
     const seen = /* @__PURE__ */ new Set();
@@ -16713,7 +17316,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     return hook == null ? result : [];
   }
-  function bindVoiceCapabilitySubscriptions(currentFibers, family, gates, allowed, realtimeOnly = false) {
+  function bindVoiceCapabilitySubscriptions(currentFibers, family, gates, allowed, realtimeOnly = false, names = ["voice.realtime", "voice.thread"]) {
     const fibers = currentFibers();
     const restores = [];
     const bindings = [];
@@ -16731,7 +17334,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           const matches = [...members].filter(([, member]) => member.cacheKey === deps[0]);
           if (matches.length !== 1 || typeof matches[0]?.[0] !== "string") continue;
           const parameter = JSON.parse(matches[0][0]);
-          if (!record2(parameter) || Object.keys(parameter).some((key) => key !== "name" && key !== "hostId") || parameter.name !== "voice.realtime" && parameter.name !== "voice.thread" || realtimeOnly && parameter.name !== "voice.realtime" || parameter.hostId !== void 0 && parameter.hostId !== "local" || parameter.name === "voice.thread" && parameter.hostId !== "local")
+          if (!record2(parameter) || Object.keys(parameter).some((key) => key !== "name" && key !== "hostId") || !names.some((name) => parameter.name === name) || 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;
@@ -16805,11 +17408,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       },
       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)
-          )
-        );
+        return bindings.every(({ subscriber, signal, instance }) => {
+          try {
+            const snapshot = subscriber.getSnapshot();
+            const instanceSnapshot = instance.getSnapshot();
+            if (!capable(snapshot) || !capable(instanceSnapshot) || !equal(snapshot, instanceSnapshot))
+              return false;
+            return current.some((hook) => {
+              const committed = hook.next?.memoizedState;
+              return Array.isArray(hook.memoizedState) && hook.memoizedState[0] === subscriber && hook.memoizedState[1]?.[0] === signal && hook.next?.queue === instance && capable(committed) && equal(committed, snapshot) && (!realtimeOnly || snapshot.isCapable);
+            });
+          } catch {
+            return false;
+          }
+        });
       }
     };
   }
@@ -16818,7 +17430,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var GLOBAL = "__codexhostVoiceStartCapabilityV1";
   var record3 = (v) => v !== null && typeof v === "object";
   function gatewayVoiceStartRequest(request, workGateway, chatGateway = false) {
-    if (!record3(request) || request.productExperience !== "work" && request.productExperience !== "chat")
+    if (!record3(request) || request.productExperience !== "work" && request.productExperience !== "codex" && request.productExperience !== "chat")
       return false;
     if (request.source === "composer_button_existing_thread") {
       if (!record3(request.locator) || request.locator.hostId !== "local") return false;
@@ -16906,9 +17518,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         const assets = selectVoiceAssets(CLIENT_OWNED_VOICE_ASSETS, names, config2.desktopVersion);
         if (assets) {
           const shared = await importModule(`app://-/assets/${assets.shared}`);
-          if (typeof shared.Oit !== "function") throw new Error("Voice bridge unavailable");
-          shared.Oit();
-          const services = shared[CLIENT_OWNED_VOICE_SERVICES];
+          const init = "init" in assets ? assets.init : void 0;
+          if (typeof init === "string" && typeof shared[init] === "function") {
+            shared[init]();
+          }
+          const services = shared[assets.services];
           if (record3(services) && (record3(services.realtimeVoiceRuntime) || typeof services.realtimeVoiceRuntime === "function")) {
             const original = services.realtimeVoiceRuntime;
             const register = Reflect.get(original, "registerRealtimeStarter");
@@ -16928,7 +17542,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
                       ready: async () => {
                         const hook = target.__codexhostClientOwnedVoiceV1;
                         if (!record3(hook) || hook.status !== "active") return false;
-                        const bridgeClass = shared.AFt;
+                        const bridgeClass = shared[assets.bridge];
                         const result = await requestVoiceHost(
                           bridgeClass.getInstance(),
                           {},
@@ -16938,20 +17552,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
                       },
                       prepare: async (allowed) => {
                         const names2 = loadedAssetNames(target.document, target.performance);
-                        if (!auditedAppInitialAssetPresent(names2, assets.overlay))
+                        if (selectVoiceAssets(
+                          CLIENT_OWNED_VOICE_ASSETS,
+                          names2,
+                          config2.desktopVersion
+                        ) !== assets)
                           throw new Error("Unaudited voice starter");
                         const [initial, overlay] = await Promise.all([
                           importModule(`app://-/assets/${assets.initial}`),
                           importModule(`app://-/assets/${assets.overlay}`)
                         ]);
-                        if (typeof initial.njr !== "function" || typeof overlay.AvatarOverlayNativePage !== "function" || !target.document)
+                        if (typeof overlay.AvatarOverlayNativePage !== "function" || !target.document)
                           throw new Error("Voice starter owner unavailable");
                         const document = target.document;
-                        initial.njr();
+                        const { family, gates } = initializeVoiceCapabilityFamilies(initial, assets);
                         return bindVoiceCapabilitySubscriptions(
                           () => overlayVoiceStarterFibers(document, overlay.AvatarOverlayNativePage),
-                          initial.tjr,
-                          initial.uBr,
+                          family,
+                          gates,
                           allowed,
                           true
                         );
@@ -17010,4 +17628,5 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   installClientOwnedVoiceHook();
   installVoiceStartCapabilityHook();
   installOverlayThreadIsolation();
+  installOverlayExternalFollowUps();
 })();