@codexhost/cli-darwin-x64 0.15.0 → 0.16.1

package/app/desktop-controller.mjs

@@ -14952,6 +14952,8 @@ var usageStatisticsTotalsSchema = external_exports.strictObject({
   cachedInputTokens: count,
   cacheWriteInputTokens: count,
   cacheKnownInputTokens: count,
+  cacheHitCachedInputTokens: count,
+  cacheHitInputTokens: count,
   outputTokens: count,
   reasoningOutputTokens: count,
   /** USD at the public price, summed over the priced requests only. */
@@ -15838,7 +15840,10 @@ var harnessPluginRouteSchema = external_exports.object({
   harnessId: harnessPluginIdSchema,
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  permissionModeId: harnessPermissionModeIdSchema.optional()
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
+  /** A draft prewarm create: stays unsubmitted until the user's first Turn.
+   * Desktop forwards only the Model of a main-process prewarm to thread/start. */
+  prewarm: external_exports.literal(true).optional()
 }).strict();
 
 // packages/shared-contracts/dist/harness-launch-settings.js
@@ -16702,8 +16707,99 @@ function retainRendererHostResponses(client, hostId2, target) {
   };
 }
 
+// packages/desktop-control/src/renderer-prewarm-consumption.ts
+function isolateRendererPrewarmConsumption(manager, discardExternal) {
+  const record3 = (value) => value !== null && typeof value === "object";
+  if (!record3(manager) || !record3(manager.threadCreation)) return null;
+  const creation = manager.threadCreation;
+  const originalStart = manager.startConversation;
+  const original = creation.createConversation;
+  const params = creation.params;
+  if (typeof originalStart !== "function" || typeof original !== "function" || !record3(params))
+    return null;
+  const prototype = Object.getPrototypeOf(creation);
+  if (!record3(prototype) || typeof prototype.constructor !== "function") return null;
+  if (Object.keys(creation).some((key) => key !== "params" && typeof creation[key] !== "function") || /#[A-Za-z_$]/u.test(Function.prototype.toString.call(prototype.constructor)))
+    return null;
+  const pool = params.prewarmedThreadManager;
+  if (!record3(pool) || typeof pool.hasPrewarmedThread !== "function" || typeof pool.consumePrewarmedThread !== "function" || typeof pool.deletePrewarmedThread !== "function")
+    return null;
+  const consume = pool.consumePrewarmedThread;
+  const hasPrewarm = pool.hasPrewarmedThread;
+  const draftModels = /* @__PURE__ */ new Map();
+  const draftIdentity = /* @__PURE__ */ Symbol("codexhost draft creation");
+  const external = (model2) => typeof model2 === "string" && model2.startsWith("codexhost/");
+  const routedStart = function(input, options, ...args) {
+    const draftId = record3(options) ? options.clientThreadId : null;
+    const mode = record3(input) && record3(input.collaborationMode) ? input.collaborationMode : null;
+    const origin = mode ? Reflect.get(mode, draftIdentity) : void 0;
+    if (mode && record3(mode.settings) && external(mode.settings.model))
+      return originalStart.call(this, input, options, ...args);
+    const model2 = (typeof draftId === "string" ? draftModels.get(draftId) : void 0) ?? (typeof origin === "string" ? draftModels.get(origin) : void 0);
+    if (!model2) return originalStart.call(this, input, options, ...args);
+    if (!record3(input) || !record3(input.collaborationMode) || !record3(input.collaborationMode.settings))
+      throw new Error("External draft creation is missing its native Model settings");
+    const routed = {
+      ...input,
+      collaborationMode: {
+        ...input.collaborationMode,
+        settings: { ...input.collaborationMode.settings, model: model2 }
+      }
+    };
+    return originalStart.call(this, routed, options, ...args);
+  };
+  const wrapped = function(input, ...args) {
+    const mode = record3(input) && record3(input.collaborationMode) ? input.collaborationMode : null;
+    const expected = mode && record3(mode.settings) ? mode.settings.model : null;
+    const scopedPool = Object.create(pool);
+    scopedPool.hasPrewarmedThread = (...parameters) => hasPrewarm.apply(pool, parameters);
+    scopedPool.consumePrewarmedThread = async (...consumeArgs) => {
+      const warmed = await consume.apply(pool, consumeArgs);
+      if (!record3(warmed) || !record3(warmed.response)) return warmed;
+      const response = warmed.response;
+      if (!external(expected) && !external(response.model)) return warmed;
+      if (external(expected) && expected === response.model) return warmed;
+      if (record3(response.thread) && typeof response.thread.id === "string") {
+        const threadId = response.thread.id;
+        if (external(response.model)) discardExternal(threadId);
+        else
+          void Promise.resolve().then(() => pool.deletePrewarmedThread(threadId)).catch(() => void 0);
+      }
+      return null;
+    };
+    const invocation = Object.create(creation);
+    invocation.params = { ...params, prewarmedThreadManager: scopedPool };
+    return original.call(invocation, input, ...args);
+  };
+  creation.createConversation = wrapped;
+  manager.startConversation = routedStart;
+  return {
+    selectDraft(draftId, model2, creationModes = []) {
+      if (draftId === void 0) {
+        if (model2 === null) draftModels.clear();
+      } else if (model2 === null) draftModels.delete(draftId);
+      else {
+        if (!draftId.startsWith("client-new-thread:") || !external(model2))
+          throw new Error("External draft route is missing its client Thread identity");
+        draftModels.set(draftId, model2);
+        for (const mode of creationModes)
+          Object.defineProperty(mode, draftIdentity, {
+            configurable: true,
+            enumerable: true,
+            value: draftId
+          });
+      }
+    },
+    dispose() {
+      draftModels.clear();
+      if (manager.startConversation === routedStart) manager.startConversation = originalStart;
+      if (creation.createConversation === wrapped) creation.createConversation = original;
+    }
+  };
+}
+
 // packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
-function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses) {
+function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses, isolateConsumption = isolateRendererPrewarmConsumption) {
   let disposed = false;
   const originalSend = bridge.sendRequest;
   const originalPrewarm = bridge.prewarmThreadStart;
@@ -17084,26 +17180,16 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     if (threadId && knownOfficialThreadIds.has(threadId)) return false;
     return selectedModel !== null && (method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/"));
   };
-  const routeThreadStart = (parameters) => {
-    if (!isRecord3(parameters) || parameters.ephemeral === true) {
-      return parameters;
-    }
-    return {
-      ...parameters,
-      ...selectedModel === null ? {} : { model: selectedModel }
-    };
-  };
   const routedSend = (method, parameters, options) => {
     if (method === "turn/start" || method === "thread/resume" || method === "codexhost/thread/command/execute") {
       const threadId = threadIdFromParameters(parameters);
       if (threadId) externalPrewarms.delete(threadId);
     }
-    const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
     const sendBridged = () => initializeBridge().then(
-      () => enqueueBridgeRequest(method, routedParameters, options)
+      () => enqueueBridgeRequest(method, parameters, options)
     );
-    const sendDirect = () => options === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options);
-    const unresolvedThreadId = shouldResolveThreadOwnership(method, routedParameters);
+    const sendDirect = () => options === void 0 ? originalSend.call(bridge, method, parameters) : originalSend.call(bridge, method, parameters, options);
+    const unresolvedThreadId = shouldResolveThreadOwnership(method, parameters);
     if (unresolvedThreadId) {
       return resolveThreadOwnership(unresolvedThreadId).then(
         (owner) => owner === "external" ? sendBridged() : sendDirect(),
@@ -17119,7 +17205,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         }
       );
     }
-    return shouldUseBridge(method, routedParameters) ? sendBridged() : sendDirect();
+    return shouldUseBridge(method, parameters) ? sendBridged() : sendDirect();
   };
   const publishDraftWorkspace = (parameters) => {
     if (!isRecord3(parameters) || parameters.ephemeral === true) return;
@@ -17149,10 +17235,10 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
   const discardExternalPrewarms = () => {
     for (const threadId of externalPrewarms) discardExternalPrewarm(threadId);
   };
+  const restoreConsumption = isolateConsumption(manager, discardExternalPrewarm);
   const routedPrewarm = (parameters, options) => {
-    const routed = routeThreadStart(parameters);
-    const external = isRecord3(routed) && routed.ephemeral !== true && typeof routed.model === "string" && routed.model.startsWith("codexhost/");
-    const routedParameters = external ? { ...routed, codexhostPrewarm: true } : routed;
+    const external = isRecord3(parameters) && parameters.ephemeral !== true && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
+    const routedParameters = external ? { ...parameters, codexhostPrewarm: true } : parameters;
     const generation = prewarmGeneration;
     publishDraftWorkspace(routedParameters);
     const pending = shouldUseBridge("thread/start", routedParameters) ? routedSend("thread/start", routedParameters, options) : options === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options);
@@ -17205,6 +17291,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
   const policy = Object.freeze({
     state: "ready",
     hostId: hostId2,
+    scopedCreation: restoreConsumption !== null,
     owns(candidateManager, candidate, candidateHostId, candidatePrewarmedThreadManager, requiresCurrentManager) {
       return !disposed && candidateManager === manager && candidate === bridge && candidateHostId === hostId2 && candidatePrewarmedThreadManager === prewarmedThreadManager && requiresCurrentManager === !!isCurrentManager;
     },
@@ -17213,12 +17300,13 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         throw new Error("Renderer request manager is retired");
       return manager;
     },
-    select(model2) {
+    select(model2, draftId, creationModes) {
       if (disposed || isCurrentManager && !isCurrentManager())
         throw new Error("Renderer request manager is retired");
       if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
         throw new Error("Draft route Model must be a codexhost transport carrier");
       }
+      restoreConsumption?.selectDraft(draftId, model2, creationModes);
       if (selectedModel === model2) return false;
       selectedModel = model2;
       prewarmGeneration += 1;
@@ -17239,6 +17327,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       disposed = true;
       prewarmGeneration += 1;
       retireResponses();
+      restoreConsumption?.dispose();
       if (bridge.sendRequest === routedSend) bridge.sendRequest = originalSend;
       if (bridge.prewarmThreadStart === routedPrewarm) {
         bridge.prewarmThreadStart = originalPrewarm;
@@ -17275,14 +17364,14 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
 
 // packages/desktop-control/src/renderer-host-discovery.ts
 function requestManagerFromHookState(value, hostId2) {
-  const record2 = (candidate) => typeof candidate === "object" && candidate !== null;
+  const record3 = (candidate) => typeof candidate === "object" && candidate !== null;
   const manager = (candidate) => {
-    if (!record2(candidate) || !record2(candidate.requestClient) || !record2(candidate.prewarmedThreadManager))
+    if (!record3(candidate) || !record3(candidate.requestClient) || !record3(candidate.prewarmedThreadManager))
       return null;
     const bridge = candidate.requestClient;
     return typeof candidate.sendRequest === "function" && typeof bridge.sendRequest === "function" && typeof bridge.prewarmThreadStart === "function" && typeof bridge.enqueueRequest === "function" && typeof candidate.prewarmedThreadManager.discardAllPrewarmedThreads === "function" ? candidate : null;
   };
-  if (!record2(value)) return null;
+  if (!record3(value)) return null;
   const direct = manager(value) ?? manager(value.manager);
   if (direct) return direct;
   if (!hostId2 || typeof value.addManager !== "function" || typeof value.getForHostId !== "function")
@@ -17492,6 +17581,335 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
   return routing;
 }
 
+// packages/desktop-control/src/renderer-host-rpc-discovery.ts
+function findRendererAppScopeStore(root) {
+  const MAX_VISITED_FIBERS = 5e4;
+  const record3 = (value) => typeof value === "object" && value !== null;
+  const container = root.getElementById?.("root");
+  if (!record3(container)) return null;
+  const key = Object.getOwnPropertyNames(container).find(
+    (name) => name.startsWith("__reactContainer$")
+  );
+  const first = key ? container[key] : null;
+  if (!record3(first)) return null;
+  const isScopeHandle = (value) => record3(value) && record3(value.node) && "chain" in value && "scope" in value && typeof value.get === "function" && typeof value.set === "function" && typeof value.watch === "function";
+  const stack = [first];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length && seen.size < MAX_VISITED_FIBERS) {
+    const fiber = stack.pop();
+    if (seen.has(fiber)) continue;
+    seen.add(fiber);
+    let hook = fiber.memoizedState;
+    for (let index = 0; record3(hook) && "next" in hook && index < 150; index += 1) {
+      const state = hook.memoizedState;
+      const handle = record3(state) ? state.current : null;
+      if (isScopeHandle(handle)) {
+        let node = handle.node;
+        const nodes = /* @__PURE__ */ new Set();
+        while (record3(node.parent) && !nodes.has(node.parent)) {
+          nodes.add(node);
+          node = node.parent;
+        }
+        const bindings = node.familyBindings;
+        return record3(bindings) && typeof bindings.get === "function" && typeof bindings.entries === "function" ? node : null;
+      }
+      hook = hook.next;
+    }
+    if (record3(fiber.sibling)) stack.push(fiber.sibling);
+    if (record3(fiber.child)) stack.push(fiber.child);
+  }
+  return null;
+}
+function findRendererHostRpcFamily(store) {
+  const record3 = (value) => typeof value === "object" && value !== null;
+  const families = /* @__PURE__ */ new Set();
+  for (const [definition, members] of store.familyBindings) {
+    if (!record3(definition) || definition.kind !== "signal-family") continue;
+    if (!record3(members) || typeof members.get !== "function") continue;
+    for (const [hostId2, member] of members) {
+      if (typeof hostId2 !== "string" || !record3(member)) continue;
+      const signal = member.value;
+      if (!record3(signal) || typeof signal.get !== "function") continue;
+      let value;
+      try {
+        value = signal.get();
+      } catch {
+        continue;
+      }
+      if (record3(value) && Object.keys(value).length === 2 && typeof value.status === "string" && record3(value.client) && value.client.hostId === hostId2 && "rpc" in value.client) {
+        families.add(members);
+        break;
+      }
+    }
+  }
+  if (families.size !== 1) return null;
+  return { store, family: families.values().next().value };
+}
+function resolveRendererHostRpc(discovery, hostId2) {
+  const record3 = (value2) => typeof value2 === "object" && value2 !== null;
+  const signal = discovery.family.get(hostId2)?.value;
+  if (!record3(signal) || typeof signal.get !== "function") return null;
+  let value;
+  try {
+    value = signal.get();
+  } catch {
+    return null;
+  }
+  if (!record3(value) || value.status !== "ready" || !record3(value.client) || value.client.hostId !== hostId2)
+    return null;
+  const rpc = value.client.rpc;
+  return typeof rpc === "function" || record3(rpc) ? rpc : null;
+}
+function rendererHostRpcHostIds(discovery) {
+  return [...discovery.family.keys()].filter(
+    (hostId2) => typeof hostId2 === "string"
+  );
+}
+
+// packages/desktop-control/src/renderer-host-rpc-routing.ts
+function installRendererHostRpcRouting(root, target, dependencies) {
+  const existing = target.__codexhostHostRoutingV1;
+  if (existing) return existing;
+  let disposed = false;
+  let discovery = null;
+  const routes = /* @__PURE__ */ new Map();
+  const read = () => {
+    if (disposed) return null;
+    if (!discovery) {
+      const store = dependencies.findStore(root);
+      discovery = store ? dependencies.findFamily(store) : null;
+    }
+    return discovery;
+  };
+  if (!read()) return null;
+  const isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const externalDrafts = /* @__PURE__ */ new Map();
+  const selectedModels = /* @__PURE__ */ new Map();
+  const prewarmCarrier = (carrier) => {
+    const prefix = "codexhost/plugin-v1@";
+    if (!carrier.startsWith(prefix)) return null;
+    try {
+      const json2 = carrier.slice(prefix.length).replace(/[a-f0-9]{2}/gu, (byte) => String.fromCharCode(Number.parseInt(byte, 16)));
+      const route = JSON.parse(json2);
+      if (!isRecord3(route)) return null;
+      const payload = [...JSON.stringify({ ...route, prewarm: true })].map((character) => character.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+      return `${prefix}${payload}`;
+    } catch {
+      return null;
+    }
+  };
+  const publishDraftWorkspace = (hostId2, cwd) => {
+    if (typeof cwd !== "string" || cwd.length === 0) return;
+    const drafts = isRecord3(target.__codexhostDraftWorkspacesV1) ? target.__codexhostDraftWorkspacesV1 : {};
+    if (drafts[hostId2] === cwd) return;
+    drafts[hostId2] = cwd;
+    Object.defineProperty(target, "__codexhostDraftWorkspacesV1", {
+      configurable: true,
+      value: drafts
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(
+        new CustomEvent("codexhost:draft-workspace", { detail: { hostId: hostId2, cwd } })
+      );
+    }
+  };
+  const routeCreationCall = (message) => {
+    if (!Array.isArray(message) || message.length !== 2 || message[0] !== "push") return message;
+    const expression = message[1];
+    if (!Array.isArray(expression) || expression.length !== 4 || expression[0] !== "pipeline")
+      return message;
+    const [, importId, path3, args] = expression;
+    if (!Array.isArray(path3) || path3.length !== 1 || !Array.isArray(args)) return message;
+    const [input, options] = args;
+    if (!isRecord3(input) || !isRecord3(input.collaborationMode)) return message;
+    const settings = input.collaborationMode.settings;
+    if (!isRecord3(settings)) return message;
+    let model2 = null;
+    if (path3[0] === "startConversation") {
+      const draftId = isRecord3(options) ? options.clientThreadId : null;
+      model2 = typeof draftId === "string" ? externalDrafts.get(draftId)?.model ?? null : null;
+    } else if (path3[0] === "prewarmConversation") {
+      if (input.ephemeral !== true) publishDraftWorkspace("local", input.cwd);
+      const selected = selectedModels.get("local");
+      model2 = selected ? prewarmCarrier(selected) : null;
+    }
+    if (!model2) return message;
+    return [
+      "push",
+      [
+        "pipeline",
+        importId,
+        path3,
+        [
+          {
+            ...input,
+            collaborationMode: { ...input.collaborationMode, settings: { ...settings, model: model2 } }
+          },
+          ...args.slice(1)
+        ]
+      ]
+    ];
+  };
+  const port = dependencies.portPrototype;
+  const originalPostMessage = port.postMessage;
+  const postMessage = function(message, ...rest) {
+    let routed = message;
+    try {
+      routed = disposed ? message : routeCreationCall(message);
+    } catch {
+      routed = message;
+    }
+    return originalPostMessage.call(this, routed, ...rest);
+  };
+  port.postMessage = postMessage;
+  const createRoute = (hostId2, rpc) => {
+    let retired = false;
+    const isCurrent = () => !retired && !disposed && routes.get(hostId2)?.rpc === rpc;
+    const manager = Object.freeze({
+      kind: "main-process-rpc",
+      getHostId: () => hostId2,
+      sendRequest(method, params, options) {
+        if (!isCurrent())
+          return Promise.reject(new Error(`Renderer request manager is retired for ${hostId2}`));
+        return options === void 0 ? rpc.sendRequest(method, params) : rpc.sendRequest(method, params, options);
+      },
+      // The main process broadcasts every app-server notification to its windows,
+      // including codexhost methods Desktop's own notification table drops.
+      addNotificationCallback(methods, listener) {
+        const accepted = new Set(typeof methods === "string" ? [methods] : methods);
+        const onMessage = (event) => {
+          const { source, data } = event;
+          if (source != null && source !== target) return;
+          if (!isRecord3(data) || data.type !== "mcp-notification" || data.hostId !== hostId2 || typeof data.method !== "string" || !accepted.has(data.method) || !isCurrent())
+            return;
+          listener({ method: data.method, params: data.params });
+        };
+        target.addEventListener?.("message", onMessage);
+        return () => target.removeEventListener?.("message", onMessage);
+      }
+    });
+    const clearDrafts = () => {
+      for (const [draftId, draft] of externalDrafts) {
+        if (draft.owner === policy) externalDrafts.delete(draftId);
+      }
+    };
+    const clear = () => isCurrent() ? Promise.resolve(rpc.clearPrewarmedThreads()).then(() => void 0) : Promise.reject(new Error("Renderer request manager is retired"));
+    const policy = Object.freeze({
+      state: "ready",
+      hostId: hostId2,
+      scopedCreation: true,
+      requestTarget: () => {
+        if (!isCurrent()) throw new Error("Renderer request manager is retired");
+        return manager;
+      },
+      select(model2, draftId) {
+        if (!isCurrent()) throw new Error("Renderer request manager is retired");
+        if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
+          throw new Error("Draft route Model must be a codexhost transport carrier");
+        }
+        if (draftId === void 0) {
+          if (model2 === null) clearDrafts();
+        } else if (model2 === null) {
+          if (externalDrafts.get(draftId)?.owner === policy) externalDrafts.delete(draftId);
+        } else {
+          if (!draftId.startsWith("client-new-thread:"))
+            throw new Error("External draft route is missing its client Thread identity");
+          externalDrafts.set(draftId, { model: model2, owner: policy });
+        }
+        if ((selectedModels.get(hostId2) ?? null) === model2) return false;
+        if (model2 === null) selectedModels.delete(hostId2);
+        else selectedModels.set(hostId2, model2);
+        void clear().catch(() => void 0);
+        return true;
+      },
+      clear,
+      dispose() {
+        if (retired) return;
+        retired = true;
+        clearDrafts();
+        selectedModels.delete(hostId2);
+      }
+    });
+    return { hostId: hostId2, manager, policy };
+  };
+  const retire = (hostId2) => {
+    const entry = routes.get(hostId2);
+    routes.delete(hostId2);
+    entry?.route.policy.dispose();
+  };
+  const routeFor = (hostId2) => {
+    const current = read();
+    const rpc = current ? dependencies.resolve(current, hostId2) : null;
+    const previous = routes.get(hostId2);
+    if (rpc && previous?.rpc === rpc) return previous.route;
+    retire(hostId2);
+    if (!rpc) return null;
+    const route = createRoute(hostId2, rpc);
+    routes.set(hostId2, { route, rpc });
+    return route;
+  };
+  const publish = (route) => {
+    const policy = route?.policy;
+    if (target.__codexhostDraftPrewarmPolicyV1 === policy) return;
+    Object.defineProperty(target, "__codexhostDraftPrewarmPolicyV1", {
+      configurable: true,
+      value: policy
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(new CustomEvent("codexhost:draft-prewarm-policy-changed"));
+    }
+  };
+  const composerHostId = (composer) => {
+    const hostIds = new Set(dependencies.composerHostIds(composer).hostIds);
+    const hostId2 = hostIds.size === 1 ? hostIds.values().next().value : null;
+    return typeof hostId2 === "string" && hostId2 ? hostId2 : null;
+  };
+  const routing = {
+    knownHostIds() {
+      const current = read();
+      return current ? dependencies.hostIds(current) : [];
+    },
+    forHost(hostId2) {
+      return hostId2 && !disposed ? routeFor(hostId2) : null;
+    },
+    hostIdForComposer(composer) {
+      if (disposed) return null;
+      try {
+        return composerHostId(composer);
+      } catch {
+        return null;
+      }
+    },
+    forComposer(composer) {
+      if (disposed) return null;
+      let hostId2;
+      try {
+        hostId2 = composerHostId(composer);
+      } catch {
+        hostId2 = null;
+      }
+      const route = hostId2 ? routeFor(hostId2) : null;
+      if (!composer) publish(route);
+      return route;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const hostId2 of [...routes.keys()]) retire(hostId2);
+      discovery = null;
+      externalDrafts.clear();
+      selectedModels.clear();
+      if (port.postMessage === postMessage) port.postMessage = originalPostMessage;
+      if (target.__codexhostHostRoutingV1 === routing) {
+        delete target.__codexhostHostRoutingV1;
+        publish(null);
+      }
+    }
+  };
+  Object.defineProperty(target, "__codexhostHostRoutingV1", { configurable: true, value: routing });
+  return routing;
+}
+
 // packages/desktop-control/src/renderer-draft-prewarm-policy.ts
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
@@ -17503,14 +17921,41 @@ function directRendererInstaller() {
     const resolveRendererHostManager = ${resolveRendererHostManager.toString()};
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
-    const routing = (${installRendererHostRouting.toString()})(
-      document, window,
-      (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
+    const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
+    const discover = (root) =>
+      discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState);
+    const installNative = () => (${installRendererHostRouting.toString()})(
+      document, window, discover,
       (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
       (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
+        isolateRendererPrewarmConsumption,
       ),
     );
+    const installRpc = () => typeof MessagePort !== 'function' ? null : (${installRendererHostRpcRouting.toString()})(document, window, {
+      findStore: ${findRendererAppScopeStore.toString()},
+      findFamily: ${findRendererHostRpcFamily.toString()},
+      resolve: ${resolveRendererHostRpc.toString()},
+      hostIds: ${rendererHostRpcHostIds.toString()},
+      composerHostIds: (composer) => {
+        const source = composer?.matches?.('[data-codex-composer], [contenteditable="true"][role="textbox"]')
+          ? { querySelectorAll: () => [composer] }
+          : (composer ?? document);
+        return discover(source);
+      },
+      portPrototype: MessagePort.prototype,
+    });
+    // Desktop 26.1027 moved AppServerManagers to the main process. Older builds
+    // expose native managers in Renderer hook state; the main-process mode only
+    // applies when none is visible and its per-Host RPC store is identified.
+    const routing = (() => {
+      if (window.__codexhostHostRoutingV1) return window.__codexhostHostRoutingV1;
+      const native = discover(document);
+      if (native.managers.length || native.registries.length) return installNative();
+      const rpc = installRpc();
+      if (rpc) return rpc;
+      throw new Error('Renderer Host request manager is unavailable');
+    })();
     // Publish a default draft policy only when its Host is unambiguous. Host
     // connections can be ready even when multiple Composers coexist.
     const composerRoute = routing.forComposer();
@@ -17547,6 +17992,114 @@ function installRendererDraftPrewarmPolicyDirect(renderer) {
   );
 }
 
+// packages/desktop-control/src/renderer-loaded-modules.ts
+var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var MAX_MODULES = 4096;
+function nativeModuleCatalogExpression(urls, complete, owner) {
+  return `Object.defineProperty(globalThis, '__codexhostLoadedModulesV1', {
+    configurable: true,
+    value: Object.freeze({ owner: ${JSON.stringify(owner)}, documentUrl: location.href, complete: ${complete}, urls: Object.freeze(${JSON.stringify(urls)}) })
+  }); void 0`;
+}
+async function installRendererLoadedModules(renderer) {
+  const owner = crypto.randomUUID();
+  const contexts = /* @__PURE__ */ new Map();
+  const contextIds = /* @__PURE__ */ new Map();
+  const dirty = /* @__PURE__ */ new Set();
+  let ready = false;
+  let disposed = false;
+  let timer;
+  let publishing = Promise.resolve();
+  const flush = () => {
+    clearTimeout(timer);
+    timer = void 0;
+    const pending = [...dirty];
+    dirty.clear();
+    publishing = publishing.catch(() => void 0).then(async () => {
+      for (const uniqueId of pending) {
+        const context = contexts.get(uniqueId);
+        if (!context || disposed) continue;
+        const response = await renderer.command("Runtime.evaluate", {
+          expression: nativeModuleCatalogExpression([...context.urls], context.complete, owner),
+          uniqueContextId: uniqueId
+        });
+        if (record2(response) && record2(response.exceptionDetails))
+          throw new Error("Loaded Renderer module catalog publication failed");
+      }
+    });
+    return publishing;
+  };
+  const schedule = (uniqueId) => {
+    dirty.add(uniqueId);
+    if (ready && timer === void 0)
+      timer = setTimeout(() => {
+        void flush().catch((error51) => {
+          console.error("Could not publish loaded Renderer modules", error51);
+        });
+      }, 10);
+  };
+  const remove = (id) => {
+    const uniqueId = contextIds.get(id);
+    contextIds.delete(id);
+    if (uniqueId) {
+      contexts.delete(uniqueId);
+      dirty.delete(uniqueId);
+    }
+  };
+  const listeners = [
+    renderer.on("Runtime.executionContextCreated", (params) => {
+      const context = record2(params) ? params.context : null;
+      if (!record2(context) || typeof context.id !== "number" || typeof context.uniqueId !== "string" || !record2(context.auxData) || context.auxData.isDefault !== true)
+        return;
+      contextIds.set(context.id, context.uniqueId);
+      contexts.set(context.uniqueId, { urls: /* @__PURE__ */ new Set(), complete: true });
+      schedule(context.uniqueId);
+    }),
+    renderer.on("Runtime.executionContextDestroyed", (params) => {
+      if (record2(params) && typeof params.executionContextId === "number")
+        remove(params.executionContextId);
+    }),
+    renderer.on("Runtime.executionContextsCleared", () => {
+      contextIds.clear();
+      contexts.clear();
+      dirty.clear();
+    }),
+    renderer.on("Debugger.scriptParsed", (params) => {
+      if (!record2(params) || params.isModule !== true || params.hasSourceURL === true || typeof params.url !== "string" || typeof params.executionContextId !== "number")
+        return;
+      const uniqueId = contextIds.get(params.executionContextId);
+      const context = uniqueId ? contexts.get(uniqueId) : null;
+      if (!context || !uniqueId || context.urls.has(params.url)) return;
+      if (context.urls.size >= MAX_MODULES) context.complete = false;
+      else context.urls.add(params.url);
+      schedule(uniqueId);
+    })
+  ];
+  const dispose = () => {
+    disposed = true;
+    clearTimeout(timer);
+    for (const unsubscribe of listeners) unsubscribe();
+    for (const uniqueId of contexts.keys())
+      void renderer.command("Runtime.evaluate", {
+        expression: `if (globalThis.__codexhostLoadedModulesV1 === undefined || globalThis.__codexhostLoadedModulesV1?.owner === ${JSON.stringify(owner)}) { ${nativeModuleCatalogExpression([], false, owner)} }`,
+        uniqueContextId: uniqueId
+      }).catch(() => void 0);
+    contexts.clear();
+    contextIds.clear();
+    dirty.clear();
+  };
+  try {
+    await renderer.command("Runtime.enable");
+    await renderer.command("Debugger.enable");
+    ready = true;
+    await flush();
+    return dispose;
+  } catch (error51) {
+    dispose();
+    throw error51;
+  }
+}
+
 // packages/desktop-control/src/renderer-cdp-control-session.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -17691,21 +18244,23 @@ async function waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs
 }
 async function installTarget(target, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations) {
   const renderer = await operations.connect(target.webSocketDebuggerUrl);
+  let disposeModules;
   try {
-    await renderer.command("Runtime.enable");
+    disposeModules = await installRendererLoadedModules(renderer);
     await renderer.command("Page.enable");
     await renderer.command("Page.addScriptToEvaluateOnNewDocument", { source: rendererSource });
     await evaluateSource(renderer, rendererSource);
     const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(renderer);
     const binding = await waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs);
-    return { renderer, snapshot: { target, draftPrewarmPolicy, binding } };
+    return { renderer, snapshot: { target, draftPrewarmPolicy, binding }, disposeModules };
   } catch (error51) {
+    disposeModules?.();
     renderer.close();
     throw error51;
   }
 }
 var InstalledRendererCdpControlSession = class {
-  constructor(renderer, rendererCdpEndpoint2, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot) {
+  constructor(renderer, rendererCdpEndpoint2, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot, disposeModules) {
     this.renderer = renderer;
     this.rendererCdpEndpoint = rendererCdpEndpoint2;
     this.rendererSource = rendererSource;
@@ -17714,6 +18269,7 @@ var InstalledRendererCdpControlSession = class {
     this.pollIntervalMs = pollIntervalMs;
     this.operations = operations;
     this.currentSnapshot = currentSnapshot;
+    this.disposeModules = disposeModules;
   }
   renderer;
   rendererCdpEndpoint;
@@ -17723,6 +18279,7 @@ var InstalledRendererCdpControlSession = class {
   pollIntervalMs;
   operations;
   currentSnapshot;
+  disposeModules;
   #closed = false;
   get snapshot() {
     return this.currentSnapshot;
@@ -17745,8 +18302,10 @@ var InstalledRendererCdpControlSession = class {
         this.pollIntervalMs,
         this.operations
       );
+      this.disposeModules();
       this.renderer.close();
       this.renderer = replacement.renderer;
+      this.disposeModules = replacement.disposeModules;
       this.currentSnapshot = replacement.snapshot;
       return this.currentSnapshot;
     }
@@ -17771,8 +18330,10 @@ var InstalledRendererCdpControlSession = class {
         this.pollIntervalMs,
         this.operations
       );
+      this.disposeModules();
       this.renderer.close();
       this.renderer = replacement.renderer;
+      this.disposeModules = replacement.disposeModules;
       this.currentSnapshot = replacement.snapshot;
       return this.currentSnapshot;
     }
@@ -17789,6 +18350,7 @@ var InstalledRendererCdpControlSession = class {
   close() {
     if (this.#closed) return;
     this.#closed = true;
+    this.disposeModules();
     this.renderer.close();
   }
 };
@@ -17826,7 +18388,8 @@ async function createRendererCdpControlSession(options) {
     timeoutMs,
     pollIntervalMs,
     operations,
-    installed.snapshot
+    installed.snapshot,
+    installed.disposeModules
   );
 }
 function installRendererCdpControlSession(options) {