@codexhost/cli-darwin-arm64 0.17.0 → 0.17.1

package/app/desktop-controller.mjs

@@ -16818,9 +16818,10 @@ function isolateRendererPrewarmConsumption(manager, discardExternal) {
 }
 
 // packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
-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;
@@ -16904,7 +16905,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     bridgeRequests.clear();
     if (isRemoteControlHost && terminate) {
       void Promise.resolve(
-        originalSend.call(bridge, "process/kill", { processHandle: failedProcessHandle })
+        controlSend("process/kill", { processHandle: failedProcessHandle })
       ).catch(() => void 0);
     }
   };
@@ -17067,7 +17068,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:\\",
@@ -17088,7 +17089,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     const operation = async () => {
       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(value)}
 `)
@@ -17363,7 +17364,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       bridgeReadyTimeout = null;
       if (isRemoteControlHost && (bridgeState === "starting" || bridgeState === "ready")) {
         void Promise.resolve(
-          originalSend.call(bridge, "process/kill", { processHandle: bridgeProcessHandle })
+          controlSend("process/kill", { processHandle: bridgeProcessHandle })
         ).catch(() => void 0);
       }
       bridgeState = "disposed";
@@ -17465,10 +17466,11 @@ function resolveRendererHostManager(discovery, hostId2, managerFrom = requestMan
 }
 
 // packages/desktop-control/src/renderer-host-routing.ts
-function installRendererHostRouting(root, target, discover, resolve, createPolicy) {
+function installRendererHostRouting(root, target, discover, resolve, createPolicy, readConnection, publishRouting = true) {
   const existing = target.__codexhostHostRoutingV1;
-  if (existing) return existing;
-  target.__codexhostDraftPrewarmPolicyV1?.dispose?.();
+  if (publishRouting && existing) return existing;
+  if (publishRouting)
+    target.__codexhostDraftPrewarmPolicyV1?.dispose?.();
   let disposed = false;
   let lastDiscovery = null;
   const routes = /* @__PURE__ */ new Map();
@@ -17495,10 +17497,20 @@ 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(
+    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,
@@ -17508,7 +17520,7 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
       return previous.route;
     }
     retire(hostId2);
-    if (!manager) return null;
+    if (!manager || connection === null) return null;
     const bridge = manager.requestClient;
     const prewarmed = manager.prewarmedThreadManager;
     const policy = createPolicy(
@@ -17517,13 +17529,14 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
       hostId2,
       target,
       prewarmed,
-      () => lookup(hostId2) === manager && manager.requestClient === bridge && manager.prewarmedThreadManager === 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;
     Object.defineProperty(target, "__codexhostDraftPrewarmPolicyV1", {
@@ -17576,7 +17589,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);
         }
       }
@@ -17596,7 +17609,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;
 }
 
@@ -17690,17 +17707,37 @@ function installRendererHostRpcRouting(root, target, dependencies) {
   const existing = target.__codexhostHostRoutingV1;
   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 = dependencies.findStore(root);
       discovery = store ? dependencies.findFamily(store) : null;
+    } catch {
+      discovery = null;
     }
     return discovery;
   };
   if (!read()) return null;
+  const native = () => {
+    if (disposed) return null;
+    try {
+      nativeRouting ??= dependencies.nativeRouting?.() ?? null;
+    } catch {
+    }
+    return nativeRouting;
+  };
+  const connectionFor = (hostId2) => {
+    if (!hostId2.startsWith("remote-control:")) return void 0;
+    try {
+      return dependencies.readConnection?.(hostId2);
+    } catch {
+      return null;
+    }
+  };
+  const sameConnection = (previous, current) => previous === void 0 ? current === void 0 : current?.owner === previous.owner && current.revision === previous.revision;
   const isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
   const externalDrafts = /* @__PURE__ */ new Map();
   const selectedModels = /* @__PURE__ */ new Map();
@@ -17778,16 +17815,25 @@ function installRendererHostRpcRouting(root, target, dependencies) {
   const postMessage = function(message, ...rest) {
     let routed = message;
     try {
-      routed = disposed ? message : routeCreationCall(message);
+      routed = disposed || routes.size === 0 ? message : routeCreationCall(message);
     } catch {
       routed = message;
     }
     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 && dependencies.resolve(current, hostId2) === rpc;
+      } catch {
+        return false;
+      }
+    };
     const manager = Object.freeze({
       kind: "main-process-rpc",
       getHostId: () => hostId2,
@@ -17860,15 +17906,23 @@ function installRendererHostRpcRouting(root, target, dependencies) {
     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 ? dependencies.resolve(current, hostId2) : null;
     const previous = routes.get(hostId2);
-    if (rpc && previous?.rpc === rpc) return previous.route;
+    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) => {
@@ -17883,14 +17937,22 @@ function installRendererHostRpcRouting(root, target, dependencies) {
     }
   };
   const composerHostId = (composer) => {
+    const nativeHostId = native()?.hostIdForComposer(composer);
+    if (nativeHostId) return nativeHostId;
     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() {
+      if (disposed) return [];
       const current = read();
-      return current ? dependencies.hostIds(current) : [];
+      return [
+        .../* @__PURE__ */ new Set([
+          ...current ? dependencies.hostIds(current) : [],
+          ...native()?.knownHostIds?.() ?? []
+        ])
+      ];
     },
     forHost(hostId2) {
       return hostId2 && !disposed ? routeFor(hostId2) : null;
@@ -17906,18 +17968,22 @@ function installRendererHostRpcRouting(root, target, dependencies) {
     forComposer(composer) {
       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;
     },
     dispose() {
       if (disposed) return;
       disposed = true;
+      nativeRouting?.dispose();
+      nativeRouting = null;
       for (const hostId2 of [...routes.keys()]) retire(hostId2);
       discovery = null;
       externalDrafts.clear();
@@ -17933,6 +17999,30 @@ function installRendererHostRpcRouting(root, target, dependencies) {
   return routing;
 }
 
+// packages/desktop-control/src/renderer-connection-generation.ts
+function readRendererConnectionGeneration(store, hostId2) {
+  if (!store) return void 0;
+  const record3 = (value) => value !== null && typeof value === "object";
+  const candidates = /* @__PURE__ */ new Set();
+  for (const members of store.familyBindings.values()) {
+    const value = members.get(hostId2)?.value;
+    if (record3(value) && record3(value.state$) && record3(value.revision$) && record3(value.appServerVersion$) && typeof value.state$.get === "function" && typeof value.revision$.get === "function")
+      candidates.add(value);
+  }
+  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/src/renderer-draft-prewarm-policy.ts
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
@@ -17945,15 +18035,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()},
@@ -17967,14 +18061,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();
@@ -17984,8 +18085,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
@@ -18145,6 +18244,781 @@ async function installRendererLoadedModules(renderer) {
   }
 }
 
+// packages/desktop-control/src/renderer-native-rpc-discovery.ts
+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(value) {
+  if (value === null || typeof value !== "object")
+    return { scope: false, services: false, controller: false };
+  const candidate = value;
+  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 dependencies = nativeManagerDependencies(
+      factory.name,
+      functions.map((entry) => entry.value?.description ?? "")
+    );
+    if (!dependencies) return false;
+    for (const [role, entries] of roles) {
+      const id = entries[0]?.value?.objectId;
+      if (!id) return false;
+      await attach(role, id);
+    }
+    for (const [role, name] of Object.entries(dependencies)) {
+      const value = bindings.find((entry) => entry.name === name)?.value?.objectId;
+      if (!value) return false;
+      await attach(role, value);
+    }
+    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 snapshot of snapshots) {
+      const fn = snapshot.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 id = binding.value.objectId;
+          const response = await call(
+            id,
+            `function(){return (${nativeRpcObjectShape.toString()})(this)}`
+          );
+          const shape = response.result.value;
+          if (shape?.scope) handles.push(id);
+          if (shape?.controller && (await call(id, "function(fn){return this.collectAppStateSnapshot===fn}", [
+            { objectId: fn }
+          ])).result.value === true)
+            controllers.push(id);
+        }
+        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/src/renderer-native-rpc-runtime.ts
+function installNativeRpcRemoteControl(components, target, dependencies) {
+  if (target.__codexhostNativeRpcRemoteControlV1) return true;
+  const routing = target.__codexhostHostRoutingV1;
+  if (!routing) return false;
+  const adapted = dependencies.createService(
+    components,
+    (hostId2, upstream) => dependencies.createManager(
+      components,
+      hostId2,
+      upstream,
+      target,
+      dependencies.createPolicy,
+      dependencies.createChannel,
+      dependencies.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 installation = {
+    dispose() {
+      if (target.__codexhostNativeRpcRemoteControlV1 !== installation) 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 = () => {
+    installation.dispose();
+    originalDispose.call(routing);
+  };
+  target.__codexhostNativeRpcRemoteControlV1 = installation;
+  return true;
+}
+
+// packages/desktop-control/src/renderer-native-remote-manager.ts
+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 record3 = (value) => value !== null && typeof value === "object";
+  const dispatch = (type, payload) => {
+    if ((type === "mcp-request" || type === "thread-prewarm-start") && record3(payload) && record3(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: record3(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,
+      (id) => manager?.getConversation(id)?.threadAccess
+    );
+    client.setAppServerVersion(source.getAppServerVersion());
+    manager = components.createManager(
+      components.scope,
+      hostId2,
+      client,
+      components.isHostForConversation.bind(null, components.scope),
+      (get, id) => get(components.imageDefinition, id),
+      { 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 || !record3(data) || data.hostId !== hostId2)
+        return;
+      const ownOrigin = record3(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(record3(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 id of [...client.requestPromises.keys()])
+          client.onError(id, 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/src/renderer-native-rpc-channel.ts
+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 value = JSON.stringify(event.data);
+      const reader = readers.shift();
+      if (reader) reader.resolve(value);
+      else values.push(value);
+    });
+    port.start();
+    const result = {
+      send(message) {
+        if (closed) throw failure;
+        port.postMessage(JSON.parse(message));
+      },
+      receive() {
+        if (closed) return Promise.reject(failure);
+        const value = values.shift();
+        return value !== void 0 ? Promise.resolve(value) : 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/src/renderer-native-rpc-service.ts
+function createNativeRpcService(components, createRemote) {
+  const source = components.services.appServerManagers.dup();
+  const routes = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Set();
+  let refs = 1;
+  const record3 = (value) => value !== null && typeof value === "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 value = members.get(hostId2)?.value;
+      if (record3(value) && Object.hasOwn(value, "state$") && Object.hasOwn(value, "revision$") && Object.hasOwn(value, "appServerVersion$"))
+        found.push({ state$: value.state$, revision$: value.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/src/renderer-native-rpc-interactions.ts
+function retainNativeRpcInteractions(upstream, manager, hostId2) {
+  let disposed = false;
+  const retained = /* @__PURE__ */ new Set();
+  const requests = /* @__PURE__ */ new Map();
+  const reads = /* @__PURE__ */ new Map();
+  const record3 = (value) => value !== null && typeof value === "object";
+  const read = (threadId) => {
+    const existing = reads.get(threadId);
+    if (existing) {
+      existing.dirty = true;
+      return existing.promise;
+    }
+    const entry = { promise: Promise.resolve(), dirty: false };
+    reads.set(threadId, entry);
+    entry.promise = Promise.resolve().then(async () => {
+      do {
+        if (disposed) break;
+        entry.dirty = false;
+        const pending = upstream.getConversation(threadId);
+        retained.add(pending);
+        try {
+          const conversation = await pending;
+          if (disposed || entry.dirty || !record3(conversation) || !Array.isArray(conversation.requests))
+            continue;
+          const previous = requests.get(threadId) ?? /* @__PURE__ */ new Set();
+          const next = /* @__PURE__ */ new Set();
+          for (const request of conversation.requests) {
+            if (!record3(request) || typeof request.method !== "string" || !record3(request.params) || (request.params.threadId ?? request.params.conversationId) !== threadId || 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(threadId, next);
+          else requests.delete(threadId);
+        } finally {
+          if (retained.delete(pending)) pending[Symbol.dispose]();
+        }
+      } while (!disposed && entry.dirty);
+    }).finally(() => {
+      reads.delete(threadId);
+    });
+    return entry.promise;
+  };
+  const event = (value) => {
+    if (disposed || !record3(value) || typeof value.conversationId !== "string") return;
+    void read(value.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(value) {
+        if (record3(value) && record3(value.params) && typeof value.params.threadId === "string")
+          event({ conversationId: value.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) => record3(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/src/renderer-native-rpc-install.ts
+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/src/renderer-cdp-control-session.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -18402,7 +19276,11 @@ var InstalledRendererCdpControlSession = class {
 var defaultOperations = {
   listTargets: (endpoint, signal) => listCdpTargets(endpoint, fetch, signal),
   connect: (webSocketDebuggerUrl) => CdpClient.connect(webSocketDebuggerUrl),
-  installDraftPrewarmPolicy: installRendererDraftPrewarmPolicyDirect
+  async installDraftPrewarmPolicy(renderer) {
+    const status = await installRendererDraftPrewarmPolicyDirect(renderer);
+    await installNativeRpcRemoteControlDirect(renderer);
+    return status;
+  }
 };
 async function createRendererCdpControlSession(options) {
   const enabledAgents = options.enabledAgents;