@codexhost/cli-darwin-arm64 0.17.0 → 0.17.2

package/app/host-runtime.mjs

@@ -21005,6 +21005,22 @@ var threadSteeringInspectParamsSchema = external_exports.object({
   text: external_exports.string().optional()
 }).strict();
 var THREAD_STEER_DELIVERY_PARAM = "codexhostSteerDelivery";
+var THREAD_STEERING_CONTEXT_PARAM = "codexhost_external_steering";
+var threadSteeringContextSchema = external_exports.object({
+  kind: external_exports.literal("application"),
+  value: external_exports.string().transform((text, context) => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      context.addIssue({ code: "custom", message: "Invalid steering context JSON" });
+      return external_exports.NEVER;
+    }
+  }).pipe(external_exports.object({
+    expectedTurnId: hostTurnIdSchema,
+    clientUserMessageId: external_exports.string().min(1),
+    delivery: external_exports.enum(["newTurn", "activeTurn"])
+  }).strict())
+}).strict().transform((context) => context.value);
 var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
 var threadSteeringInspectResultSchema = external_exports.object({
   delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
@@ -22685,9 +22701,10 @@ function isolateRendererPrewarmConsumption(manager, discardExternal) {
 }
 
 // packages/desktop-control/dist/renderer-draft-prewarm-runtime.js
-function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses, isolateConsumption = isolateRendererPrewarmConsumption) {
+function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses, isolateConsumption = isolateRendererPrewarmConsumption, sendControlRequest) {
   let disposed = false;
   const originalSend = bridge.sendRequest;
+  const controlSend = (method, parameters) => sendControlRequest ? sendControlRequest(method, parameters) : originalSend.call(bridge, method, parameters);
   const originalPrewarm = bridge.prewarmThreadStart;
   const originalOnNotification = manager.onNotification;
   const originalDispatchAppServerResponse = manager.dispatchAppServerResponse;
@@ -22773,7 +22790,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       bridge.onError(requestId, error51);
     bridgeRequests.clear();
     if (isRemoteControlHost && terminate) {
-      void Promise.resolve(originalSend.call(bridge, "process/kill", { processHandle: failedProcessHandle })).catch(() => void 0);
+      void Promise.resolve(controlSend("process/kill", { processHandle: failedProcessHandle })).catch(() => void 0);
     }
   };
   const resetFailedBridge = () => {
@@ -22936,7 +22953,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     ];
     const startedProcessHandle = bridgeProcessHandle;
     try {
-      const started = originalSend.call(bridge, "process/spawn", {
+      const started = controlSend("process/spawn", {
         command,
         processHandle: startedProcessHandle,
         cwd: "C:\\",
@@ -22959,7 +22976,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       await startBridge();
       if (bridgeState !== "ready")
         throw transportError("is not ready");
-      await originalSend.call(bridge, "process/writeStdin", {
+      await controlSend("process/writeStdin", {
         processHandle: bridgeProcessHandle,
         deltaBase64: utf8Base64(`${JSON.stringify(value2)}
 `)
@@ -23240,7 +23257,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         globalThis.clearTimeout(bridgeReadyTimeout);
       bridgeReadyTimeout = null;
       if (isRemoteControlHost && (bridgeState === "starting" || bridgeState === "ready")) {
-        void Promise.resolve(originalSend.call(bridge, "process/kill", { processHandle: bridgeProcessHandle })).catch(() => void 0);
+        void Promise.resolve(controlSend("process/kill", { processHandle: bridgeProcessHandle })).catch(() => void 0);
       }
       bridgeState = "disposed";
       const disposedError = transportError("was disposed");
@@ -23342,11 +23359,12 @@ function resolveRendererHostManager(discovery, hostId2, managerFrom = requestMan
 }
 
 // packages/desktop-control/dist/renderer-host-routing.js
-function installRendererHostRouting(root, target, discover, resolve, createPolicy) {
+function installRendererHostRouting(root, target, discover, resolve, createPolicy, readConnection, publishRouting = true) {
   const existing = target.__codexhostHostRoutingV1;
-  if (existing)
+  if (publishRouting && existing)
     return existing;
-  target.__codexhostDraftPrewarmPolicyV1?.dispose?.();
+  if (publishRouting)
+    target.__codexhostDraftPrewarmPolicyV1?.dispose?.();
   let disposed = false;
   let lastDiscovery = null;
   const routes = /* @__PURE__ */ new Map();
@@ -23374,23 +23392,36 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
     routes.delete(hostId2);
     entry?.route.policy.dispose();
   };
+  const connectionFor = (hostId2) => {
+    if (!hostId2.startsWith("remote-control:"))
+      return void 0;
+    try {
+      return readConnection?.(hostId2);
+    } catch {
+      return null;
+    }
+  };
+  const sameConnection = (expected, current) => expected === void 0 ? current === void 0 : current?.owner === expected.owner && current.revision === expected.revision;
   const routeFor = (hostId2, discovery) => {
     const manager = lookup(hostId2, discovery);
+    const connection = connectionFor(hostId2);
     const previous = routes.get(hostId2);
-    if (manager && previous?.route.manager === manager && previous.bridge === manager.requestClient && previous.prewarmed === manager.prewarmedThreadManager && previous.route.policy.owns(manager, manager.requestClient, hostId2, manager.prewarmedThreadManager, true)) {
+    if (manager && previous?.route.manager === manager && previous.bridge === manager.requestClient && previous.prewarmed === manager.prewarmedThreadManager && sameConnection(previous.connection, connection) && previous.route.policy.owns(manager, manager.requestClient, hostId2, manager.prewarmedThreadManager, true)) {
       return previous.route;
     }
     retire(hostId2);
-    if (!manager)
+    if (!manager || connection === null)
       return null;
     const bridge = manager.requestClient;
     const prewarmed = manager.prewarmedThreadManager;
-    const policy = createPolicy(manager, bridge, hostId2, target, prewarmed, () => lookup(hostId2) === manager && manager.requestClient === bridge && manager.prewarmedThreadManager === prewarmed);
+    const policy = createPolicy(manager, bridge, hostId2, target, prewarmed, () => lookup(hostId2) === manager && sameConnection(connection, connectionFor(hostId2)) && manager.requestClient === bridge && manager.prewarmedThreadManager === prewarmed);
     const route = { hostId: hostId2, manager, policy };
-    routes.set(hostId2, { route, bridge, prewarmed });
+    routes.set(hostId2, { route, bridge, prewarmed, connection });
     return route;
   };
   const publish = (route) => {
+    if (!publishRouting)
+      return;
     const policy = route?.policy;
     if (target.__codexhostDraftPrewarmPolicyV1 === policy)
       return;
@@ -23444,7 +23475,7 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
       if (!composer) {
         for (const [hostId3, entry] of routes) {
           const manager = lookup(hostId3, discovery);
-          if (manager !== entry.route.manager || manager.requestClient !== entry.bridge || manager.prewarmedThreadManager !== entry.prewarmed)
+          if (manager !== entry.route.manager || manager.requestClient !== entry.bridge || manager.prewarmedThreadManager !== entry.prewarmed || !sameConnection(entry.connection, connectionFor(hostId3)))
             retire(hostId3);
         }
       }
@@ -23467,7 +23498,11 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
       }
     }
   };
-  Object.defineProperty(target, "__codexhostHostRoutingV1", { configurable: true, value: routing });
+  if (publishRouting)
+    Object.defineProperty(target, "__codexhostHostRoutingV1", {
+      configurable: true,
+      value: routing
+    });
   return routing;
 }
 
@@ -23522,7 +23557,9 @@ function findRendererHostRpcFamily(store) {
     if (!record6(members) || typeof members.get !== "function")
       continue;
     for (const [hostId2, member] of members) {
-      if (typeof hostId2 !== "string" || !record6(member))
+      if (typeof hostId2 !== "string" || !/^(?:local$|durable$|remote[-:])/u.test(hostId2))
+        continue;
+      if (!record6(member))
         continue;
       const signal = member.value;
       if (!record6(signal) || typeof signal.get !== "function")
@@ -23569,19 +23606,43 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
   if (existing)
     return existing;
   let disposed = false;
+  let nativeRouting = null;
   let discovery = null;
   const routes = /* @__PURE__ */ new Map();
   const read = () => {
     if (disposed)
       return null;
-    if (!discovery) {
+    try {
       const store = dependencies2.findStore(root);
-      discovery = store ? dependencies2.findFamily(store) : null;
+      const bound = store && discovery?.store === store ? [...store.familyBindings.values()].includes(discovery.family) : false;
+      if (!bound)
+        discovery = store ? dependencies2.findFamily(store) : null;
+    } catch {
+      discovery = null;
     }
     return discovery;
   };
   if (!read())
     return null;
+  const native = () => {
+    if (disposed)
+      return null;
+    try {
+      nativeRouting ??= dependencies2.nativeRouting?.() ?? null;
+    } catch {
+    }
+    return nativeRouting;
+  };
+  const connectionFor = (hostId2) => {
+    if (!hostId2.startsWith("remote-control:"))
+      return void 0;
+    try {
+      return dependencies2.readConnection?.(hostId2);
+    } catch {
+      return null;
+    }
+  };
+  const sameConnection = (previous, current) => previous === void 0 ? current === void 0 : current?.owner === previous.owner && current.revision === previous.revision;
   const isRecord19 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
   const externalDrafts = /* @__PURE__ */ new Map();
   const selectedModels = /* @__PURE__ */ new Map();
@@ -23667,16 +23728,25 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
   const postMessage = function(message2, ...rest) {
     let routed = message2;
     try {
-      routed = disposed ? message2 : routeCreationCall(message2);
+      routed = disposed || routes.size === 0 ? message2 : routeCreationCall(message2);
     } catch {
       routed = message2;
     }
     return originalPostMessage.call(this, routed, ...rest);
   };
   port.postMessage = postMessage;
-  const createRoute = (hostId2, rpc) => {
+  const createRoute = (hostId2, rpc, connection) => {
     let retired = false;
-    const isCurrent = () => !retired && !disposed && routes.get(hostId2)?.rpc === rpc;
+    const isCurrent = () => {
+      if (retired || disposed || routes.get(hostId2)?.rpc !== rpc || !sameConnection(connection, connectionFor(hostId2)))
+        return false;
+      try {
+        const current = read();
+        return !!current && dependencies2.resolve(current, hostId2) === rpc;
+      } catch {
+        return false;
+      }
+    };
     const manager = Object.freeze({
       kind: "main-process-rpc",
       getHostId: () => hostId2,
@@ -23759,17 +23829,25 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
     routes.delete(hostId2);
     entry?.route.policy.dispose();
   };
-  const routeFor = (hostId2) => {
+  const routeFor = (hostId2, nativeRoute) => {
+    if (disposed)
+      return null;
+    const connection = connectionFor(hostId2);
+    const preferred = nativeRoute === void 0 ? native()?.forHost(hostId2) : nativeRoute;
+    if (connection === null || preferred) {
+      retire(hostId2);
+      return connection === null ? null : preferred ?? null;
+    }
     const current = read();
     const rpc = current ? dependencies2.resolve(current, hostId2) : null;
     const previous = routes.get(hostId2);
-    if (rpc && previous?.rpc === rpc)
+    if (rpc && previous?.rpc === rpc && sameConnection(previous.connection, connection))
       return previous.route;
     retire(hostId2);
     if (!rpc)
       return null;
-    const route = createRoute(hostId2, rpc);
-    routes.set(hostId2, { route, rpc });
+    const route = createRoute(hostId2, rpc, connection);
+    routes.set(hostId2, { route, rpc, connection });
     return route;
   };
   const publish = (route) => {
@@ -23785,14 +23863,24 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
     }
   };
   const composerHostId = (composer) => {
+    const nativeHostId = native()?.hostIdForComposer(composer);
+    if (nativeHostId)
+      return nativeHostId;
     const hostIds = new Set(dependencies2.composerHostIds(composer).hostIds);
     const hostId2 = hostIds.size === 1 ? hostIds.values().next().value : null;
     return typeof hostId2 === "string" && hostId2 ? hostId2 : null;
   };
   const routing = {
     knownHostIds() {
+      if (disposed)
+        return [];
       const current = read();
-      return current ? dependencies2.hostIds(current) : [];
+      return [
+        .../* @__PURE__ */ new Set([
+          ...current ? dependencies2.hostIds(current) : [],
+          ...native()?.knownHostIds?.() ?? []
+        ])
+      ];
     },
     forHost(hostId2) {
       return hostId2 && !disposed ? routeFor(hostId2) : null;
@@ -23810,12 +23898,14 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
       if (disposed)
         return null;
       let hostId2;
+      let preferred = null;
       try {
-        hostId2 = composerHostId(composer);
+        preferred = native()?.forComposer(composer) ?? null;
+        hostId2 = preferred?.hostId ?? composerHostId(composer);
       } catch {
         hostId2 = null;
       }
-      const route = hostId2 ? routeFor(hostId2) : null;
+      const route = hostId2 ? routeFor(hostId2, preferred) : null;
       if (!composer)
         publish(route);
       return route;
@@ -23824,6 +23914,8 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
       if (disposed)
         return;
       disposed = true;
+      nativeRouting?.dispose();
+      nativeRouting = null;
       for (const hostId2 of [...routes.keys()])
         retire(hostId2);
       discovery = null;
@@ -23841,6 +23933,34 @@ function installRendererHostRpcRouting(root, target, dependencies2) {
   return routing;
 }
 
+// packages/desktop-control/dist/renderer-connection-generation.js
+function readRendererConnectionGeneration(store, hostId2) {
+  if (!store)
+    return void 0;
+  const record6 = (value2) => value2 !== null && typeof value2 === "object";
+  const candidates = /* @__PURE__ */ new Set();
+  for (const members of store.familyBindings.values()) {
+    const value2 = members.get(hostId2)?.value;
+    if (record6(value2) && record6(value2.state$) && record6(value2.revision$) && record6(value2.appServerVersion$) && typeof value2.state$.get === "function" && typeof value2.revision$.get === "function")
+      candidates.add(value2);
+  }
+  if (!candidates.size)
+    return void 0;
+  if (candidates.size !== 1)
+    return null;
+  const owner = candidates.values().next().value;
+  if (!owner)
+    return null;
+  const state = owner.state$;
+  const revision = owner.revision$;
+  try {
+    const current = revision.get();
+    return state.get() === "connected" && typeof current === "number" && Number.isSafeInteger(current) ? { owner, revision: current } : null;
+  } catch {
+    return null;
+  }
+}
+
 // packages/desktop-control/dist/renderer-draft-prewarm-policy.js
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
@@ -23853,15 +23973,19 @@ function directRendererInstaller() {
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
     const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
+    const findRendererAppScopeStore = ${findRendererAppScopeStore.toString()};
+    const readRendererConnectionGeneration = ${readRendererConnectionGeneration.toString()};
     const discover = (root) =>
       discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState);
-    const installNative = () => (${installRendererHostRouting.toString()})(
+    const installNative = (publishRouting = true) => (${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,
       ),
+      (hostId) => readRendererConnectionGeneration(findRendererAppScopeStore(document), hostId),
+      publishRouting,
     );
     const installRpc = () => typeof MessagePort !== 'function' ? null : (${installRendererHostRpcRouting.toString()})(document, window, {
       findStore: ${findRendererAppScopeStore.toString()},
@@ -23875,14 +23999,21 @@ function directRendererInstaller() {
         return discover(source);
       },
       portPrototype: MessagePort.prototype,
+      nativeRouting: () => {
+        const native = discover(document);
+        return native.managers.length || native.registries.length ? installNative(false) : null;
+      },
+      readConnection: (hostId) => readRendererConnectionGeneration(findRendererAppScopeStore(document), hostId),
     });
     const connected = (routing) => routing.forComposer() !== null ||
       ['local', ...(routing.knownHostIds?.() ?? [])].some((hostId) => routing.forHost(hostId) !== null);
     let nativeReady = false;
-    // A legacy registry can remain mounted without a usable native manager.
-    // Prefer a ready native route, then try the identified main-process RPC store.
+    // Mixed layouts can expose native managers for only some Hosts. Keep one
+    // router that selects a native owner or the current ready RPC peer per Host.
     const routing = (() => {
       if (window.__codexhostHostRoutingV1) return window.__codexhostHostRoutingV1;
+      const rpc = installRpc();
+      if (rpc) return rpc;
       const native = discover(document);
       if (native.managers.length || native.registries.length) {
         const routing = installNative();
@@ -23892,8 +24023,6 @@ function directRendererInstaller() {
         }
         routing.dispose();
       }
-      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
@@ -24062,6 +24191,873 @@ async function installRendererLoadedModules(renderer) {
   }
 }
 
+// packages/desktop-control/dist/renderer-native-rpc-discovery.js
+function nativeManagerDependencies(factoryName, callers) {
+  const identifier = "[$A-Z_a-z][$\\w]*";
+  const escaped = factoryName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const pattern = new RegExp(`${escaped}\\((${identifier}),(${identifier}),\\1\\.get\\((${identifier}),\\2\\),(${identifier})\\.bind\\(null,\\1\\),\\((${identifier}),(${identifier})\\)=>\\5\\((${identifier}),\\6\\)\\)`);
+  const matches = callers.flatMap((source) => {
+    const match = pattern.exec(source);
+    return match?.[3] && match[4] && match[7] ? [
+      {
+        requestDefinition: match[3],
+        isHostForConversation: match[4],
+        imageDefinition: match[7]
+      }
+    ] : [];
+  });
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function nativeRpcRole(source) {
+  if (["dispatchMessageFromView", "threadProjectAssignments", "queuedMessageCoordination"].every((part) => source.includes(part)))
+    return "createManager";
+  if (["collectAppStateSnapshot", "getReviewPaneSnapshotMetrics", "registerReplayAdmission"].every((part) => source.includes(part)))
+    return "createController";
+  if (["getWorkInProgress", "getCachedThreadSearchSnapshot", "registerReplayAdmission"].every((part) => source.includes(part)))
+    return "RpcManager";
+  if (["prewarmedThreadManager", "onNotification", "dispatchAppServerResponse"].every((part) => source.includes(part)))
+    return "Manager";
+  return void 0;
+}
+function nativeRpcObjectShape(value2) {
+  if (value2 === null || typeof value2 !== "object")
+    return { scope: false, services: false, controller: false };
+  const candidate = value2;
+  const own = (keys) => keys.every((key) => Object.hasOwn(candidate, key));
+  const methods = (keys) => keys.every((key) => typeof candidate[key] === "function");
+  return {
+    scope: own(["node", "scope", "get", "set", "watch"]) && methods(["get", "set", "watch"]),
+    services: own(["appServerManagers", "remoteConnections", "applicationMenu"]) && typeof candidate.appServerManagers?.subscribe === "function",
+    controller: own(["forHost", "collectAppStateSnapshot", "getReviewPaneSnapshotMetrics", "dispose"]) && methods(["forHost", "collectAppStateSnapshot", "getReviewPaneSnapshotMetrics", "dispose"])
+  };
+}
+async function withNativeRpcComponents(client, install) {
+  const group = `codexhost-native-rpc-${crypto.randomUUID()}`;
+  const command = async (method, params) => client.command(method, params);
+  const evaluate = (expression) => command("Runtime.evaluate", { expression, awaitPromise: true, objectGroup: group });
+  const properties = (objectId) => command("Runtime.getProperties", { objectId, ownProperties: true });
+  const call = (objectId, functionDeclaration, args = []) => command("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    arguments: args,
+    objectGroup: group,
+    returnByValue: true
+  });
+  try {
+    const initial = await evaluate(String.raw`(() => {
+      const catalog = globalThis.__codexhostLoadedModulesV1;
+      if (!catalog?.complete || catalog.documentUrl !== location.href) return null;
+      const urls = catalog.urls.filter(url => /^app:\/\/-\/assets\/(?:renderer-app-server-managers|app-shared)-[^/]+\.js$/.test(url));
+      return { document, urls };
+    })()`);
+    if (!initial.result.objectId)
+      return false;
+    const holder = initial.result.objectId;
+    const catalog = await call(holder, "function(){return this.urls}");
+    const urls = catalog.result.value;
+    if (!Array.isArray(urls) || urls.length !== 2)
+      return false;
+    const managerUrl = urls.find((url2) => url2.includes("renderer-app-server-managers"));
+    const sharedUrl = urls.find((url2) => url2.includes("app-shared"));
+    if (!managerUrl || !sharedUrl)
+      return false;
+    const attach = async (name, objectId) => {
+      const result = await call(holder, "function(name,value){if(this.document!==document)throw Error('Renderer Realm changed');this[name]=value;return true}", [{ value: name }, { objectId }]);
+      if (result.exceptionDetails)
+        throw new Error("Native RPC discovery lost its Renderer Realm");
+    };
+    const imported = await evaluate(`import(${JSON.stringify(managerUrl)})`);
+    if (!imported.result.objectId)
+      return false;
+    const exports = (await properties(imported.result.objectId)).result.filter((entry) => entry.value?.type === "function");
+    let bindings = [];
+    for (const entry of exports.slice(0, 3)) {
+      if (!entry.value?.objectId)
+        continue;
+      const scopes = (await properties(entry.value.objectId)).internalProperties?.find((entry2) => entry2.name === "[[Scopes]]")?.value?.objectId;
+      if (!scopes)
+        continue;
+      const modules = (await properties(scopes)).result.filter((entry2) => entry2.value?.description?.startsWith("Module") && entry2.value.objectId);
+      const moduleId = modules[0]?.value?.objectId;
+      if (modules.length !== 1 || !moduleId)
+        continue;
+      bindings = (await properties(moduleId)).result;
+      break;
+    }
+    const functions = bindings.filter((entry) => entry.value?.type === "function");
+    const roles = /* @__PURE__ */ new Map();
+    for (const entry of functions) {
+      const role = nativeRpcRole(entry.value?.description ?? "");
+      if (role)
+        roles.set(role, [...roles.get(role) ?? [], entry]);
+    }
+    if (["createManager", "Manager", "RpcManager", "createController"].some((role) => roles.get(role)?.length !== 1))
+      return false;
+    const factory = roles.get("createManager")?.[0];
+    if (!factory)
+      return false;
+    const dependencies2 = nativeManagerDependencies(factory.name, functions.map((entry) => entry.value?.description ?? ""));
+    if (!dependencies2)
+      return false;
+    for (const [role, entries] of roles) {
+      const id2 = entries[0]?.value?.objectId;
+      if (!id2)
+        return false;
+      await attach(role, id2);
+    }
+    for (const [role, name] of Object.entries(dependencies2)) {
+      const value2 = bindings.find((entry) => entry.name === name)?.value?.objectId;
+      if (!value2)
+        return false;
+      await attach(role, value2);
+    }
+    const shared = await evaluate(`import(${JSON.stringify(sharedUrl)})`);
+    if (!shared.result.objectId)
+      return false;
+    const sharedExports = (await properties(shared.result.objectId)).result;
+    const sessions = sharedExports.filter((entry) => entry.value?.type === "function" && ["getRemoteMain", "getStats", "drain", "getMainImport"].every((word) => entry.value?.description?.includes(word)));
+    const sessionId = sessions[0]?.value?.objectId;
+    if (sessions.length !== 1 || !sessionId)
+      return false;
+    await attach("RpcSession", sessionId);
+    const serviceMatches = await command("Runtime.callFunctionOn", {
+      objectId: shared.result.objectId,
+      functionDeclaration: `function(){return [...new Set(Object.values(this).filter(value => (${nativeRpcObjectShape.toString()})(value).services))]}`,
+      objectGroup: group
+    });
+    if (!serviceMatches.result.objectId)
+      return false;
+    const services = (await properties(serviceMatches.result.objectId)).result.flatMap((entry) => entry.value?.type === "object" && entry.value.objectId ? [entry.value.objectId] : []);
+    const serviceId = services[0];
+    if (services.length !== 1 || !serviceId)
+      return false;
+    await attach("services", serviceId);
+    const prototype = await evaluate("Object.getPrototypeOf(async function(){})");
+    if (!prototype.result.objectId)
+      return false;
+    const objects = await command("Runtime.queryObjects", {
+      prototypeObjectId: prototype.result.objectId,
+      objectGroup: group
+    });
+    if (!objects.objects.objectId)
+      return false;
+    const filtered = await command("Runtime.callFunctionOn", {
+      objectId: objects.objects.objectId,
+      functionDeclaration: 'function(){return this.filter(fn=>fn.name==="collectAppStateSnapshot"&&String(fn).includes("collectSnapshot")).slice(0,9)}',
+      objectGroup: group
+    });
+    if (!filtered.result.objectId)
+      return false;
+    const snapshots = (await properties(filtered.result.objectId)).result.filter((entry) => entry.value?.type === "function");
+    if (snapshots.length > 8)
+      return false;
+    const owners = [];
+    for (const snapshot2 of snapshots) {
+      const fn = snapshot2.value?.objectId;
+      if (!fn)
+        continue;
+      const scopes = (await properties(fn)).internalProperties?.find((entry) => entry.name === "[[Scopes]]")?.value?.objectId;
+      if (!scopes)
+        continue;
+      for (const scope of (await properties(scopes)).result) {
+        if (!scope.value?.description?.startsWith("Closure") || !scope.value.objectId)
+          continue;
+        const candidates = (await properties(scope.value.objectId)).result;
+        const controllers = [], handles = [];
+        for (const binding of candidates) {
+          if (binding.value?.type !== "object" || !binding.value.objectId)
+            continue;
+          const id2 = binding.value.objectId;
+          const response = await call(id2, `function(){return (${nativeRpcObjectShape.toString()})(this)}`);
+          const shape = response.result.value;
+          if (shape?.scope)
+            handles.push(id2);
+          if (shape?.controller && (await call(id2, "function(fn){return this.collectAppStateSnapshot===fn}", [
+            { objectId: fn }
+          ])).result.value === true)
+            controllers.push(id2);
+        }
+        const controller = controllers[0], handle = handles[0];
+        if (controllers.length === 1 && handles.length === 1 && controller && handle)
+          owners.push({ controller, scope: handle });
+      }
+    }
+    const owner = owners[0];
+    if (owners.length !== 1 || !owner)
+      return false;
+    await attach("controller", owner.controller);
+    await attach("scope", owner.scope);
+    return await install(holder);
+  } finally {
+    await client.command("Runtime.releaseObjectGroup", { objectGroup: group }).catch(() => void 0);
+  }
+}
+
+// packages/desktop-control/dist/renderer-native-rpc-runtime.js
+function installNativeRpcRemoteControl(components, target, dependencies2) {
+  if (target.__codexhostNativeRpcRemoteControlV1)
+    return true;
+  const routing = target.__codexhostHostRoutingV1;
+  if (!routing)
+    return false;
+  const adapted = dependencies2.createService(components, (hostId2, upstream) => dependencies2.createManager(components, hostId2, upstream, target, dependencies2.createPolicy, dependencies2.createChannel, dependencies2.retainInteractions));
+  const controller = components.controller;
+  const originalHost = routing.forHost, originalComposer = routing.forComposer, originalDispose = routing.dispose;
+  controller.dispose();
+  let replacement;
+  try {
+    replacement = components.createController(components.scope, adapted.service);
+  } catch (error51) {
+    replacement = components.createController(components.scope, components.services.appServerManagers);
+    throw error51;
+  } finally {
+    adapted.service[Symbol.dispose]();
+    controller.forHost = (hostId2) => replacement.forHost(hostId2);
+    controller.collectAppStateSnapshot = (hostId2, options) => replacement.collectAppStateSnapshot(hostId2, options);
+    controller.getReviewPaneSnapshotMetrics = (hostId2) => replacement.getReviewPaneSnapshotMetrics(hostId2);
+    controller.dispose = () => replacement.dispose();
+  }
+  const forHost = (hostId2) => {
+    const route = adapted.route(hostId2);
+    return route === void 0 ? originalHost.call(routing, hostId2) : route;
+  };
+  const forComposer = (composer) => {
+    const hostId2 = routing.hostIdForComposer(composer);
+    return hostId2 ? forHost(hostId2) : originalComposer.call(routing, composer);
+  };
+  routing.forHost = forHost;
+  routing.forComposer = forComposer;
+  const installation2 = {
+    dispose() {
+      if (target.__codexhostNativeRpcRemoteControlV1 !== installation2)
+        return;
+      delete target.__codexhostNativeRpcRemoteControlV1;
+      replacement.dispose();
+      replacement = components.createController(components.scope, components.services.appServerManagers);
+      if (routing.forHost === forHost)
+        routing.forHost = originalHost;
+      if (routing.forComposer === forComposer)
+        routing.forComposer = originalComposer;
+      routing.dispose = originalDispose;
+    }
+  };
+  routing.dispose = () => {
+    installation2.dispose();
+    originalDispose.call(routing);
+  };
+  target.__codexhostNativeRpcRemoteControlV1 = installation2;
+  return true;
+}
+
+// packages/desktop-control/dist/renderer-native-remote-manager.js
+function createNativeRemoteManager(components, hostId2, original, target, createPolicy, createChannel, retainInteractions) {
+  const source = components.scope.get(components.requestDefinition, hostId2);
+  const upstream = original.dup();
+  let manager;
+  let policy;
+  let interactions;
+  let disposed = false;
+  const pending = /* @__PURE__ */ new Set();
+  const send = (method, params, options) => {
+    const request = upstream.sendRequest(method, params, options);
+    const result = Promise.resolve(request).finally(() => {
+      request[Symbol.dispose]();
+      pending.delete(result);
+    });
+    pending.add(result);
+    return result;
+  };
+  const record6 = (value2) => value2 !== null && typeof value2 === "object";
+  const dispatch = (type, payload) => {
+    if ((type === "mcp-request" || type === "thread-prewarm-start") && record6(payload) && record6(payload.request)) {
+      const request = payload.request;
+      const options = {};
+      for (const key of ["priority", "timeoutMs", "source", "trace", "threadAccess"])
+        if (payload[key] !== void 0)
+          options[key] = payload[key];
+      void send(String(request.method), request.params, options).then((result) => {
+        if (!disposed)
+          client.onResult(request.id, result);
+      }, (error51) => {
+        if (!disposed)
+          client.onError(request.id, {
+            code: record6(error51) ? error51.jsonRpcCode ?? error51.code ?? -32603 : -32603,
+            message: error51 instanceof Error ? error51.message : String(error51)
+          });
+      });
+      return;
+    }
+    return source.dispatchMessage(type, payload);
+  };
+  const Constructor = source.constructor;
+  let client;
+  try {
+    client = new Constructor(hostId2, dispatch, false, (id2) => manager?.getConversation(id2)?.threadAccess);
+    client.setAppServerVersion(source.getAppServerVersion());
+    manager = components.createManager(components.scope, hostId2, client, components.isHostForConversation.bind(null, components.scope), (get, id2) => get(components.imageDefinition, id2), { dispatchMessageFromView: dispatch });
+    manager.dispatchAppServerResponse = manager.sendAppServerResponse;
+    const owned = manager;
+    const ownedPolicy = createPolicy(owned, client, hostId2, target, owned.prewarmedThreadManager, () => !disposed, void 0, void 0, (method, params) => send(method, params, { priority: "critical" }));
+    policy = ownedPolicy;
+    owned.sendAppServerResponse = (...args) => owned.dispatchAppServerResponse(...args);
+    const channel = createChannel(components, owned);
+    const nativeInteractions = retainInteractions(upstream, owned, hostId2);
+    interactions = nativeInteractions;
+    const notify = (event) => {
+      const { data, source: source2, origin } = event;
+      if (disposed || source2 != null && source2 !== target || !record6(data) || data.hostId !== hostId2)
+        return;
+      const ownOrigin = record6(target.location) ? target.location.origin : void 0;
+      if (source2 === target && ownOrigin && ownOrigin !== "null" && origin !== ownOrigin)
+        return;
+      if (data.type === "mcp-notification" && typeof data.method === "string" && !data.method.startsWith("process/"))
+        owned.onNotification(data.method, data.params);
+      if (data.type === "mcp-request")
+        owned.onRequest(record6(data.request) ? data.request : data);
+    };
+    target.addEventListener?.("message", notify);
+    return {
+      route: { hostId: hostId2, manager: owned, policy: ownedPolicy },
+      rpc: channel.rpc,
+      ready: nativeInteractions.ready,
+      dispose() {
+        if (disposed)
+          return;
+        disposed = true;
+        target.removeEventListener?.("message", notify);
+        nativeInteractions.dispose();
+        ownedPolicy.dispose();
+        client.queuedRequests.length = 0;
+        for (const id2 of [...client.requestPromises.keys()])
+          client.onError(id2, new Error("Remote Control connection retired"));
+        channel.dispose();
+        components.Manager.dispose(owned);
+        void Promise.allSettled([...pending]).then(() => upstream[Symbol.dispose]());
+      }
+    };
+  } catch (error51) {
+    interactions?.dispose();
+    policy?.dispose();
+    if (manager)
+      components.Manager.dispose(manager);
+    upstream[Symbol.dispose]();
+    throw error51;
+  }
+}
+
+// packages/desktop-control/dist/renderer-native-rpc-channel.js
+function createNativeRpcChannel(components, manager) {
+  const channel = new MessageChannel();
+  const transports = [];
+  const transport = (port) => {
+    const values = [];
+    const readers = [];
+    let closed = false;
+    let failure;
+    port.addEventListener("message", (event) => {
+      const value2 = JSON.stringify(event.data);
+      const reader = readers.shift();
+      if (reader)
+        reader.resolve(value2);
+      else
+        values.push(value2);
+    });
+    port.start();
+    const result = {
+      send(message2) {
+        if (closed)
+          throw failure;
+        port.postMessage(JSON.parse(message2));
+      },
+      receive() {
+        if (closed)
+          return Promise.reject(failure);
+        const value2 = values.shift();
+        return value2 !== void 0 ? Promise.resolve(value2) : new Promise((resolve, reject) => readers.push({ resolve, reject }));
+      },
+      abort(error51) {
+        if (closed)
+          return;
+        closed = true;
+        failure = error51 ?? new Error("Remote Control RPC manager retired");
+        values.length = 0;
+        for (const reader of readers.splice(0))
+          reader.reject(failure);
+        port.close();
+      }
+    };
+    transports.push(result);
+    return result;
+  };
+  try {
+    new components.RpcSession(transport(channel.port1), new components.RpcManager(() => manager));
+    const session = new components.RpcSession(transport(channel.port2));
+    const rpc = session.getRemoteMain();
+    return {
+      rpc,
+      dispose() {
+        rpc[Symbol.dispose]();
+        for (const transport2 of transports)
+          transport2.abort();
+      }
+    };
+  } catch (error51) {
+    for (const transport2 of transports)
+      transport2.abort(error51);
+    channel.port1.close();
+    channel.port2.close();
+    throw error51;
+  }
+}
+
+// packages/desktop-control/dist/renderer-native-rpc-service.js
+function createNativeRpcService(components, createRemote) {
+  const source = components.services.appServerManagers.dup();
+  const routes = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Set();
+  let refs = 1;
+  const record6 = (value2) => value2 !== null && typeof value2 === "object";
+  const connectionSignals = (hostId2) => {
+    let node = components.scope.node;
+    const seen = /* @__PURE__ */ new Set();
+    while (node.parent && !seen.has(node.parent) && seen.size < 100) {
+      seen.add(node);
+      node = node.parent;
+    }
+    const found = [];
+    for (const members of node.familyBindings.values()) {
+      const value2 = members.get(hostId2)?.value;
+      if (record6(value2) && Object.hasOwn(value2, "state$") && Object.hasOwn(value2, "revision$") && Object.hasOwn(value2, "appServerVersion$"))
+        found.push({ state$: value2.state$, revision$: value2.revision$ });
+    }
+    return found.length === 1 ? found[0] : void 0;
+  };
+  const service = {
+    dup() {
+      refs++;
+      return service;
+    },
+    onRpcBroken(listener) {
+      source.onRpcBroken(listener);
+    },
+    openAccount(hostId2) {
+      return source.openAccount(hostId2);
+    },
+    subscribe(hostId2, listener) {
+      if (!hostId2.startsWith("remote-control:"))
+        return source.subscribe(hostId2, listener);
+      let active = true;
+      let generation = 0;
+      let upstream;
+      let platformRequest;
+      let remote;
+      let stopWatch;
+      let previousRevision;
+      let previousState;
+      const retire = () => {
+        generation++;
+        platformRequest?.[Symbol.dispose]();
+        platformRequest = void 0;
+        remote?.dispose();
+        remote = void 0;
+        routes.set(hostId2, null);
+      };
+      const cleanup = () => {
+        if (!active)
+          return;
+        active = false;
+        stopWatch?.();
+        retire();
+        upstream?.[Symbol.dispose]();
+        upstream = void 0;
+        routes.delete(hostId2);
+        subscriptions.delete(cleanup);
+      };
+      subscriptions.add(cleanup);
+      const publish = async () => {
+        const owner = upstream;
+        const current = generation;
+        if (!owner || !active)
+          return;
+        let request;
+        try {
+          request = owner.getCodexHome();
+          platformRequest = request;
+          const home = await request;
+          if (!active || current !== generation || owner !== upstream)
+            return;
+          if (!/^(?:[A-Za-z]:[\\/]|\\\\)/u.test(home)) {
+            routes.delete(hostId2);
+            listener({ status: "ready", manager: owner });
+            return;
+          }
+          const created = createRemote(hostId2, owner);
+          remote = created;
+          await created.ready;
+          if (!active || current !== generation || owner !== upstream)
+            return;
+          routes.set(hostId2, created.route);
+          listener({ status: "ready", manager: created.rpc });
+        } catch {
+          if (active && current === generation) {
+            remote?.dispose();
+            remote = void 0;
+            routes.delete(hostId2);
+            listener({ status: "ready", manager: owner });
+          }
+        } finally {
+          if (platformRequest === request) {
+            platformRequest = void 0;
+            request?.[Symbol.dispose]();
+          }
+        }
+      };
+      const changed = (state) => {
+        if (!active)
+          return;
+        stopWatch?.();
+        stopWatch = void 0;
+        retire();
+        upstream?.[Symbol.dispose]();
+        upstream = void 0;
+        if (state.status !== "ready") {
+          listener(state);
+          return;
+        }
+        upstream = state.manager.dup();
+        listener({ status: "connecting" });
+        const signals = connectionSignals(hostId2);
+        if (!signals) {
+          void publish();
+          return;
+        }
+        previousState = void 0;
+        previousRevision = void 0;
+        stopWatch = components.scope.watch(({ get }) => {
+          const connection = get(signals.state$), revision = get(signals.revision$);
+          if (connection === previousState && revision === previousRevision)
+            return;
+          previousState = connection;
+          previousRevision = revision;
+          retire();
+          listener({ status: connection === "connected" ? "connecting" : "disconnected" });
+          if (connection === "connected")
+            void publish();
+        });
+      };
+      const original = source.subscribe(hostId2, changed);
+      const result = original.then((lease) => {
+        if (!active)
+          lease[Symbol.dispose]();
+        return {
+          onRpcBroken: (listener2) => lease.onRpcBroken(listener2),
+          [Symbol.dispose]() {
+            cleanup();
+            lease[Symbol.dispose]();
+          }
+        };
+      });
+      Object.assign(result, {
+        onRpcBroken: (listener2) => original.onRpcBroken(listener2),
+        [Symbol.dispose]() {
+          cleanup();
+          original[Symbol.dispose]();
+        }
+      });
+      return result;
+    },
+    [Symbol.dispose]() {
+      if (--refs !== 0)
+        return;
+      for (const cleanup of [...subscriptions])
+        cleanup();
+      source[Symbol.dispose]();
+    }
+  };
+  return { service, route: (hostId2) => routes.get(hostId2) };
+}
+
+// packages/desktop-control/dist/renderer-native-rpc-interactions.js
+function retainNativeRpcInteractions(upstream, manager, hostId2) {
+  let disposed = false;
+  const retained = /* @__PURE__ */ new Set();
+  const requests = /* @__PURE__ */ new Map();
+  const reads = /* @__PURE__ */ new Map();
+  const record6 = (value2) => value2 !== null && typeof value2 === "object";
+  const read = (threadId2) => {
+    const existing = reads.get(threadId2);
+    if (existing) {
+      existing.dirty = true;
+      return existing.promise;
+    }
+    const entry = { promise: Promise.resolve(), dirty: false };
+    reads.set(threadId2, entry);
+    entry.promise = Promise.resolve().then(async () => {
+      do {
+        if (disposed)
+          break;
+        entry.dirty = false;
+        const pending = upstream.getConversation(threadId2);
+        retained.add(pending);
+        try {
+          const conversation = await pending;
+          if (disposed || entry.dirty || !record6(conversation) || !Array.isArray(conversation.requests))
+            continue;
+          const previous = requests.get(threadId2) ?? /* @__PURE__ */ new Set();
+          const next = /* @__PURE__ */ new Set();
+          for (const request of conversation.requests) {
+            if (!record6(request) || typeof request.method !== "string" || !record6(request.params) || (request.params.threadId ?? request.params.conversationId) !== threadId2 || typeof request.id !== "string" && typeof request.id !== "number")
+              continue;
+            next.add(request.id);
+            if (!previous.has(request.id))
+              manager.onRequest(request);
+          }
+          if (next.size)
+            requests.set(threadId2, next);
+          else
+            requests.delete(threadId2);
+        } finally {
+          if (retained.delete(pending))
+            pending[Symbol.dispose]();
+        }
+      } while (!disposed && entry.dirty);
+    }).finally(() => {
+      reads.delete(threadId2);
+    });
+    return entry.promise;
+  };
+  const event = (value2) => {
+    if (disposed || !record6(value2) || typeof value2.conversationId !== "string")
+      return;
+    void read(value2.conversationId).catch(() => void 0);
+  };
+  const subscribe = (input) => {
+    const pending = upstream.subscribe(input);
+    retained.add(pending);
+    return Promise.resolve(pending).then((lease) => {
+      if (disposed)
+        lease[Symbol.dispose]();
+      else
+        retained.add(lease);
+    });
+  };
+  const subscriptions = [
+    "approval-request",
+    "user-input-request",
+    "mcp-elicitation-request",
+    "approval-resolved"
+  ].map((name) => subscribe({ type: "event", key: { hostId: hostId2 }, event: name, listener: event }));
+  subscriptions.push(subscribe({
+    type: "notification",
+    key: { hostId: hostId2 },
+    methods: ["serverRequest/resolved"],
+    listener(value2) {
+      if (record6(value2) && record6(value2.params) && typeof value2.params.threadId === "string")
+        event({ conversationId: value2.params.threadId });
+    }
+  }));
+  const ready = Promise.all(subscriptions).then(async () => {
+    if (disposed)
+      return;
+    const pending = upstream.getWorkInProgress();
+    retained.add(pending);
+    try {
+      const work = await pending;
+      if (disposed)
+        return;
+      if (!Array.isArray(work))
+        throw new Error("Native RPC interaction snapshot is unavailable");
+      const threadIds = new Set(work.flatMap((item) => record6(item) && typeof item.conversationId === "string" ? [item.conversationId] : []));
+      await Promise.all([...threadIds].map(read));
+    } finally {
+      if (retained.delete(pending))
+        pending[Symbol.dispose]();
+    }
+  });
+  return {
+    ready,
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const lease of retained)
+        lease[Symbol.dispose]();
+      retained.clear();
+      requests.clear();
+    }
+  };
+}
+
+// packages/desktop-control/dist/renderer-native-rpc-install.js
+async function installNativeRpcRemoteControlDirect(renderer) {
+  let attempt;
+  const probeId = crypto.randomUUID();
+  try {
+    attempt = await renderer.evaluate(`(() => {
+    if (window.__codexhostNativeRpcRemoteControlV1) return null;
+    const routing = window.__codexhostHostRoutingV1;
+    const owner = routing?.forHost('local')?.manager;
+    if (owner?.kind !== 'main-process-rpc') return null;
+    const catalog = window.__codexhostLoadedModulesV1;
+    if (!catalog?.complete) return null;
+    const key = JSON.stringify([catalog.owner, catalog.urls.filter(url => /renderer-app-server-managers|app-shared/.test(url)).sort()]);
+    const previous = window.__codexhostNativeRpcDiscoveryV1;
+    const sameOwner = previous?.key === key && previous.owner === owner;
+    if (sameOwner && (previous.state !== 'unavailable' || previous.attempts >= 3 || Date.now() < previous.nextRetryAt)) return null;
+    const token = ${JSON.stringify(probeId)};
+    window.__codexhostNativeRpcDiscoveryV1 = {
+      key, owner, token, state: 'discovering', attempts: sameOwner ? previous.attempts + 1 : 1,
+    };
+    return token;
+    })()`);
+  } catch {
+    return false;
+  }
+  if (attempt === null)
+    return false;
+  let installed = false;
+  try {
+    installed = await withNativeRpcComponents(renderer, async (objectId) => {
+      const result = await renderer.command("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: `function() {
+          if (this.document !== document) return false;
+          const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
+          const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
+          return (${installNativeRpcRemoteControl.toString()})(this, window, {
+            createPolicy: ${createDraftPrewarmPolicyBridge.toString()},
+            createManager: ${createNativeRemoteManager.toString()},
+            createChannel: ${createNativeRpcChannel.toString()},
+            createService: ${createNativeRpcService.toString()},
+            retainInteractions: ${retainNativeRpcInteractions.toString()},
+          });
+        }`,
+        returnByValue: true
+      });
+      return !result.exceptionDetails && result.result?.value === true;
+    });
+    return installed;
+  } catch {
+    return false;
+  } finally {
+    await renderer.evaluate(`(() => {
+      const status = window.__codexhostNativeRpcDiscoveryV1;
+      if (status?.token === ${JSON.stringify(attempt)}) {
+        status.state = ${JSON.stringify(installed ? "ready" : "unavailable")};
+        status.nextRetryAt = Date.now() + 5000 * 2 ** (status.attempts - 1);
+      }
+    })()`).catch(() => void 0);
+  }
+}
+
+// packages/desktop-control/dist/renderer-rpc-steering.js
+var RETRY_BASE_MS = 5e3;
+var RETRY_MAX_MS = 3e5;
+var retries = /* @__PURE__ */ new WeakMap();
+async function installRendererRpcSteeringDirect(client, now = Date.now) {
+  try {
+    const needed = await client.evaluate(`(() => {
+      const steering = window.__codexhostRpcSteeringV1;
+      if (steering && steering.controller.forHost === steering.forHost) return false;
+      steering?.release();
+      const routing=window.__codexhostHostRoutingV1;
+      return ['local', ...(routing?.knownHostIds?.() ?? [])].some(id => routing?.forHost(id)?.manager.kind === 'main-process-rpc');
+    })()`);
+    if (!needed)
+      return false;
+    const retry = retries.get(client);
+    if (retry && now() < retry.nextAt)
+      return false;
+    try {
+      await discoverAndInstall(client);
+      retries.delete(client);
+      return true;
+    } catch (error51) {
+      const attempts = (retry?.attempts ?? 0) + 1;
+      const delay7 = Math.min(RETRY_BASE_MS * 2 ** (attempts - 1), RETRY_MAX_MS);
+      retries.set(client, { attempts, nextAt: now() + delay7 });
+      console.error(`codexhost native steering discovery failed (attempt ${attempts}):`, error51 instanceof Error ? error51.message : String(error51));
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+async function discoverAndInstall(client) {
+  const group = `codexhost-rpc-steering-${crypto.randomUUID()}`;
+  const command = (method, params) => client.command(method, params);
+  const properties = (objectId) => command("Runtime.getProperties", { objectId, ownProperties: true });
+  const call = (objectId, functionDeclaration, args = []) => command("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    arguments: args,
+    objectGroup: group,
+    returnByValue: true
+  });
+  try {
+    const proto = await command("Runtime.evaluate", {
+      expression: "Object.getPrototypeOf(async function(){})",
+      objectGroup: group
+    });
+    if (!proto.result.objectId)
+      throw new Error("Native RPC steering discovery is unavailable");
+    const objects = await command("Runtime.queryObjects", {
+      prototypeObjectId: proto.result.objectId,
+      objectGroup: group
+    });
+    if (!objects.objects.objectId)
+      throw new Error("Native RPC steering discovery is unavailable");
+    const filtered = await command("Runtime.callFunctionOn", {
+      objectId: objects.objects.objectId,
+      functionDeclaration: 'function(){return this.filter(fn=>fn.name==="collectAppStateSnapshot"&&String(fn).includes("collectSnapshot")).slice(0,9)}',
+      objectGroup: group
+    });
+    if (!filtered.result.objectId)
+      throw new Error("Native RPC Controller is unavailable");
+    const snapshots = (await properties(filtered.result.objectId)).result.flatMap((entry) => entry.value?.type === "function" && entry.value.objectId ? [entry.value.objectId] : []);
+    if (snapshots.length > 8)
+      throw new Error("Native RPC Controller is ambiguous");
+    const controllers = [];
+    for (const snapshot2 of snapshots) {
+      const scopes = (await properties(snapshot2)).internalProperties?.find((entry) => entry.name === "[[Scopes]]")?.value?.objectId;
+      if (!scopes)
+        continue;
+      for (const scope of (await properties(scopes)).result) {
+        if (!scope.value?.objectId || !scope.value.description?.startsWith("Closure"))
+          continue;
+        const bindings = (await properties(scope.value.objectId)).result;
+        const owners = [];
+        let rootScope;
+        for (const binding of bindings) {
+          if (binding.value?.type !== "object" || !binding.value.objectId)
+            continue;
+          const id2 = binding.value.objectId;
+          const result2 = await call(id2, `function(){return (${nativeRpcObjectShape.toString()})(this)}`);
+          const shape = result2.result.value;
+          if (shape?.scope)
+            rootScope = id2;
+          if (shape?.controller && (await call(id2, "function(fn){return this.collectAppStateSnapshot===fn}", [
+            { objectId: snapshot2 }
+          ])).result.value === true)
+            owners.push(id2);
+        }
+        if (owners.length !== 1 || !rootScope)
+          continue;
+        const root = await call(rootScope, `function(){let node=this.node;const seen=new Set();while(node?.parent&&!seen.has(node.parent)&&seen.size<100){seen.add(node);node=node.parent}return (${findRendererAppScopeStore.toString()})(document)===node}`);
+        if (root.result.value === true)
+          controllers.push(owners[0]);
+      }
+    }
+    if (controllers.length !== 1)
+      throw new Error("Native RPC Controller is missing or ambiguous");
+    const result = await call(controllers[0], "function(){return window.__codexhostInstallRpcSteeringV1?.(this) === true}");
+    if (result.exceptionDetails || result.result.value !== true)
+      throw new Error("Native RPC steering installation failed");
+  } finally {
+    await client.command("Runtime.releaseObjectGroup", { objectGroup: group }).catch(() => void 0);
+  }
+}
+
 // packages/desktop-control/dist/renderer-cdp-control-session.js
 function isRecord2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -24289,7 +25285,12 @@ var InstalledRendererCdpControlSession = class {
 var defaultOperations = {
   listTargets: (endpoint, signal) => listCdpTargets(endpoint, fetch, signal),
   connect: (webSocketDebuggerUrl) => CdpClient.connect(webSocketDebuggerUrl),
-  installDraftPrewarmPolicy: installRendererDraftPrewarmPolicyDirect
+  async installDraftPrewarmPolicy(renderer) {
+    const status2 = await installRendererDraftPrewarmPolicyDirect(renderer);
+    await installNativeRpcRemoteControlDirect(renderer);
+    await installRendererRpcSteeringDirect(renderer);
+    return status2;
+  }
 };
 async function createRendererCdpControlSession(options) {
   const enabledAgents = options.enabledAgents;
@@ -34263,12 +35264,13 @@ var ExternalThreadRuntime = class {
     }
     try {
       const aligned = await this.#repository.alignSnapshot(thread.record, snapshot2.value);
+      const turns = aligned.record.state === "creating" && !aligned.record.nativeSessionRef && snapshot2.value.turns.length === 0 ? thread.turns : aligned.turns;
       thread.record = aligned.record;
-      thread.turns = aligned.turns;
+      thread.turns = turns;
       thread.historyHydrated = true;
       thread.thread = externalThreadValue({
         record: aligned.record,
-        turns: aligned.turns,
+        turns,
         sessionId: thread.sessionId,
         running: thread.running
       });
@@ -34559,6 +35561,7 @@ var publicSubmission = ({
 var DEFAULT_PAGE_SIZE3 = 50;
 var ExternalThreadQueue = class {
   #queues = /* @__PURE__ */ new Map();
+  #acceptedSteers = /* @__PURE__ */ new Map();
   #notifyChanged;
   #createId;
   constructor(options) {
@@ -34600,7 +35603,7 @@ var ExternalThreadQueue = class {
   async delete(threadId2, id2) {
     const items = this.#queues.get(threadId2);
     const index = items?.findIndex((item) => item.id === id2) ?? -1;
-    if (!items || index === -1) return false;
+    if (!items || index === -1) return this.#acceptedSteers.get(id2) === threadId2;
     items.splice(index, 1);
     this.#prune(threadId2);
     await this.#notifyChanged(threadId2);
@@ -34633,6 +35636,26 @@ var ExternalThreadQueue = class {
       index
     };
   }
+  /** Reserve the exact queued input before steering can finish a replacement Turn.
+   * Otherwise automatic queue advancement can deliver that input a second time. */
+  takeSteered(threadId2, clientUserMessageId, input) {
+    if (typeof clientUserMessageId !== "string") return;
+    const matches = (this.#queues.get(threadId2) ?? []).filter(
+      (item2) => item2.clientUserMessageId === clientUserMessageId
+    );
+    if (matches.length === 0) return;
+    const item = matches[0];
+    if (matches.length !== 1 || externalTurnInputText(item.input) !== externalTurnInputText(input))
+      throw new ExternalQueueError(-32602, "Queued steering input changed before delivery");
+    return this.take(threadId2, item.id);
+  }
+  async acceptSteered(threadId2, taken) {
+    this.#acceptedSteers.set(taken.submission.id, threadId2);
+    while (this.#acceptedSteers.size > 128) {
+      this.#acceptedSteers.delete(this.#acceptedSteers.keys().next().value);
+    }
+    await this.#notifyChanged(threadId2);
+  }
   restore(threadId2, taken) {
     const items = this.#items(threadId2);
     if (items.some((item) => item.id === taken.submission.id)) return;
@@ -34646,6 +35669,9 @@ var ExternalThreadQueue = class {
   }
   forget(threadId2) {
     this.#queues.delete(threadId2);
+    for (const [id2, owner] of this.#acceptedSteers) {
+      if (owner === threadId2) this.#acceptedSteers.delete(id2);
+    }
   }
   #items(threadId2) {
     let items = this.#queues.get(threadId2);
@@ -42058,7 +43084,10 @@ var AppServerHost = class {
       request,
       location,
       (hostThreadId) => this.#repository.setArchived(hostThreadId, archived),
-      "External Thread archive state could not be persisted"
+      "External Thread archive state could not be persisted",
+      // A loaded Thread whose deferred native Session never arrived (its first Turn
+      // failed first) is still on Desktop's list and must remain archivable.
+      true
     );
     if (!updated) return;
     await this.#writer.json(
@@ -42648,7 +43677,7 @@ var AppServerHost = class {
         ...arguments_2 ? { arguments: arguments_2 } : {}
       });
       if (!result.ok) throw new ExternalCommandError(-32073, result.error.message);
-      return { turnId: result.value.turnId, turn: projection.projector.pendingTurn(), gate };
+      return { turnId, turn: projection.projector.pendingTurn(), gate };
     } catch (error51) {
       restoreExecutionHost();
       thread.running = false;
@@ -43430,6 +44459,11 @@ var AppServerHost = class {
     }
   }
   async #startExternalTurn(request, thread) {
+    const context = routingParams(request).additionalContext;
+    if (isRecord18(context) && Object.hasOwn(context, THREAD_STEERING_CONTEXT_PARAM)) {
+      await this.#steerExternalTurn(request, thread, true);
+      return;
+    }
     if (this.#externalThreadBusy(thread) || this.#pendingExternalCommandRequests.has(thread.id)) {
       await this.#writer.json(
         rpcError(request, -32072, "External Thread already has an active Turn")
@@ -43601,34 +44635,61 @@ var AppServerHost = class {
       this.#diagnose(error51);
     }
   }
-  async #steerExternalTurn(request, thread) {
+  async #steerExternalTurn(request, thread, asStart = false) {
+    let queued;
+    let accepted = false;
     try {
+      let params = requestObject(request);
+      const context = params.additionalContext;
+      if (isRecord18(context) && Object.hasOwn(context, THREAD_STEERING_CONTEXT_PARAM)) {
+        const marker = threadSteeringContextSchema.safeParse(
+          context[THREAD_STEERING_CONTEXT_PARAM]
+        );
+        if (!marker.success || marker.data.clientUserMessageId !== params.clientUserMessageId || asStart && marker.data.delivery !== "newTurn")
+          throw new ExternalSteerError(-32602, "Invalid native steering preparation context");
+        if (!asStart && params.expectedTurnId !== marker.data.expectedTurnId)
+          throw new ExternalSteerError(-32074, "Native steering target changed before submission");
+        params = {
+          ...params,
+          expectedTurnId: marker.data.expectedTurnId,
+          [THREAD_STEER_DELIVERY_PARAM]: marker.data.delivery
+        };
+      }
+      queued = this.#externalQueue.takeSteered(thread.id, params.clientUserMessageId, params.input);
       const started = await this.#externalSteering.run(
         thread,
-        requestObject(request),
+        params,
         (text, assertActive) => this.#beginExternalInputTurn(
           thread,
           text,
           assertActive,
           typeof requestObject(request).clientUserMessageId === "string" ? requestObject(request).clientUserMessageId : void 0,
-          requestObject(request)[THREAD_REFERENCE_SOURCE_HOST_PARAM]
+          queued ? queued.sourceHostId : requestObject(request)[THREAD_REFERENCE_SOURCE_HOST_PARAM]
         ),
         (input) => this.#insertExternalInput(thread, input)
       );
+      accepted = true;
+      if (queued) {
+        await this.#externalQueue.acceptSteered(thread.id, queued).catch((error51) => this.#diagnose(error51));
+      }
       try {
         await this.#writer.json(
           rpcEnvelope(request, {
-            result: { turnId: started.turnId, delivery: started.delivery }
+            result: asStart ? { turn: this.#projectedTurn(thread, started.turnId).projector.pendingTurn() } : { turnId: started.turnId, delivery: started.delivery }
           })
         );
       } finally {
         started.gate.resolve();
       }
     } catch (error51) {
+      if (queued && !accepted) {
+        this.#externalQueue.restore(thread.id, queued);
+        await this.#externalQueue.notifyChanged(thread.id).catch((failure) => this.#diagnose(failure));
+      }
       await this.#writer.json(
         rpcError(
           request,
-          error51 instanceof ExternalSteerError || error51 instanceof ExternalCommandError ? error51.code : -32074,
+          error51 instanceof ExternalSteerError || error51 instanceof ExternalCommandError || error51 instanceof ExternalQueueError ? error51.code : -32074,
           errorMessage4(error51)
         )
       );