@codexhost/cli-win32-arm64 0.15.0 → 0.16.1

package/app/host-runtime.mjs

@@ -5369,7 +5369,8 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
           kind: "npm",
           node_path: await requireRegularFile(options2.nodePath, "npm Node.js executable"),
           npm_cli_path: await requireRegularFile(options2.npmCliPath, "npm CLI"),
-          npm_launcher_path: await requireRegularFile(options2.npmLauncherPath, "npm codexhost launcher")
+          npm_launcher_path: await requireRegularFile(options2.npmLauncherPath, "npm codexhost launcher"),
+          npm_package_root: requireAbsolutePath(options2.packageRoot, "npm platform package root")
         });
       } catch (error51) {
         await writeFailedStatus(common.statusPath, common.version, "npm", error51);
@@ -20114,6 +20115,8 @@ var usageStatisticsTotalsSchema = external_exports.strictObject({
   cachedInputTokens: count,
   cacheWriteInputTokens: count,
   cacheKnownInputTokens: count,
+  cacheHitCachedInputTokens: count,
+  cacheHitInputTokens: count,
   outputTokens: count,
   reasoningOutputTokens: count,
   /** USD at the public price, summed over the priced requests only. */
@@ -21024,7 +21027,10 @@ var harnessPluginRouteSchema = external_exports.object({
   harnessId: harnessPluginIdSchema,
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  permissionModeId: harnessPermissionModeIdSchema.optional()
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
+  /** A draft prewarm create: stays unsubmitted until the user's first Turn.
+   * Desktop forwards only the Model of a main-process prewarm to thread/start. */
+  prewarm: external_exports.literal(true).optional()
 }).strict();
 function encodeHarnessPluginRoute(route) {
   const parsed2 = harnessPluginRouteSchema.parse(route);
@@ -22494,8 +22500,110 @@ function retainRendererHostResponses(client, hostId2, target) {
   };
 }
 
+// packages/desktop-control/dist/renderer-prewarm-consumption.js
+function isolateRendererPrewarmConsumption(manager, discardExternal) {
+  const record5 = (value2) => value2 !== null && typeof value2 === "object";
+  if (!record5(manager) || !record5(manager.threadCreation))
+    return null;
+  const creation = manager.threadCreation;
+  const originalStart = manager.startConversation;
+  const original = creation.createConversation;
+  const params = creation.params;
+  if (typeof originalStart !== "function" || typeof original !== "function" || !record5(params))
+    return null;
+  const prototype = Object.getPrototypeOf(creation);
+  if (!record5(prototype) || typeof prototype.constructor !== "function")
+    return null;
+  if (Object.keys(creation).some((key) => key !== "params" && typeof creation[key] !== "function") || /#[A-Za-z_$]/u.test(Function.prototype.toString.call(prototype.constructor)))
+    return null;
+  const pool = params.prewarmedThreadManager;
+  if (!record5(pool) || typeof pool.hasPrewarmedThread !== "function" || typeof pool.consumePrewarmedThread !== "function" || typeof pool.deletePrewarmedThread !== "function")
+    return null;
+  const consume = pool.consumePrewarmedThread;
+  const hasPrewarm = pool.hasPrewarmedThread;
+  const draftModels = /* @__PURE__ */ new Map();
+  const draftIdentity = /* @__PURE__ */ Symbol("codexhost draft creation");
+  const external = (model2) => typeof model2 === "string" && model2.startsWith("codexhost/");
+  const routedStart = function(input, options2, ...args) {
+    const draftId = record5(options2) ? options2.clientThreadId : null;
+    const mode = record5(input) && record5(input.collaborationMode) ? input.collaborationMode : null;
+    const origin = mode ? Reflect.get(mode, draftIdentity) : void 0;
+    if (mode && record5(mode.settings) && external(mode.settings.model))
+      return originalStart.call(this, input, options2, ...args);
+    const model2 = (typeof draftId === "string" ? draftModels.get(draftId) : void 0) ?? (typeof origin === "string" ? draftModels.get(origin) : void 0);
+    if (!model2)
+      return originalStart.call(this, input, options2, ...args);
+    if (!record5(input) || !record5(input.collaborationMode) || !record5(input.collaborationMode.settings))
+      throw new Error("External draft creation is missing its native Model settings");
+    const routed = {
+      ...input,
+      collaborationMode: {
+        ...input.collaborationMode,
+        settings: { ...input.collaborationMode.settings, model: model2 }
+      }
+    };
+    return originalStart.call(this, routed, options2, ...args);
+  };
+  const wrapped = function(input, ...args) {
+    const mode = record5(input) && record5(input.collaborationMode) ? input.collaborationMode : null;
+    const expected = mode && record5(mode.settings) ? mode.settings.model : null;
+    const scopedPool = Object.create(pool);
+    scopedPool.hasPrewarmedThread = (...parameters) => hasPrewarm.apply(pool, parameters);
+    scopedPool.consumePrewarmedThread = async (...consumeArgs) => {
+      const warmed = await consume.apply(pool, consumeArgs);
+      if (!record5(warmed) || !record5(warmed.response))
+        return warmed;
+      const response = warmed.response;
+      if (!external(expected) && !external(response.model))
+        return warmed;
+      if (external(expected) && expected === response.model)
+        return warmed;
+      if (record5(response.thread) && typeof response.thread.id === "string") {
+        const threadId2 = response.thread.id;
+        if (external(response.model))
+          discardExternal(threadId2);
+        else
+          void Promise.resolve().then(() => pool.deletePrewarmedThread(threadId2)).catch(() => void 0);
+      }
+      return null;
+    };
+    const invocation = Object.create(creation);
+    invocation.params = { ...params, prewarmedThreadManager: scopedPool };
+    return original.call(invocation, input, ...args);
+  };
+  creation.createConversation = wrapped;
+  manager.startConversation = routedStart;
+  return {
+    selectDraft(draftId, model2, creationModes = []) {
+      if (draftId === void 0) {
+        if (model2 === null)
+          draftModels.clear();
+      } else if (model2 === null)
+        draftModels.delete(draftId);
+      else {
+        if (!draftId.startsWith("client-new-thread:") || !external(model2))
+          throw new Error("External draft route is missing its client Thread identity");
+        draftModels.set(draftId, model2);
+        for (const mode of creationModes)
+          Object.defineProperty(mode, draftIdentity, {
+            configurable: true,
+            enumerable: true,
+            value: draftId
+          });
+      }
+    },
+    dispose() {
+      draftModels.clear();
+      if (manager.startConversation === routedStart)
+        manager.startConversation = originalStart;
+      if (creation.createConversation === wrapped)
+        creation.createConversation = original;
+    }
+  };
+}
+
 // packages/desktop-control/dist/renderer-draft-prewarm-runtime.js
-function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses) {
+function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses, isolateConsumption = isolateRendererPrewarmConsumption) {
   let disposed = false;
   const originalSend = bridge.sendRequest;
   const originalPrewarm = bridge.prewarmThreadStart;
@@ -22885,25 +22993,15 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       return false;
     return selectedModel !== null && (method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/"));
   };
-  const routeThreadStart = (parameters) => {
-    if (!isRecord19(parameters) || parameters.ephemeral === true) {
-      return parameters;
-    }
-    return {
-      ...parameters,
-      ...selectedModel === null ? {} : { model: selectedModel }
-    };
-  };
   const routedSend = (method, parameters, options2) => {
     if (method === "turn/start" || method === "thread/resume" || method === "codexhost/thread/command/execute") {
       const threadId2 = threadIdFromParameters(parameters);
       if (threadId2)
         externalPrewarms.delete(threadId2);
     }
-    const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
-    const sendBridged = () => initializeBridge().then(() => enqueueBridgeRequest(method, routedParameters, options2));
-    const sendDirect = () => options2 === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options2);
-    const unresolvedThreadId = shouldResolveThreadOwnership(method, routedParameters);
+    const sendBridged = () => initializeBridge().then(() => enqueueBridgeRequest(method, parameters, options2));
+    const sendDirect = () => options2 === void 0 ? originalSend.call(bridge, method, parameters) : originalSend.call(bridge, method, parameters, options2);
+    const unresolvedThreadId = shouldResolveThreadOwnership(method, parameters);
     if (unresolvedThreadId) {
       return resolveThreadOwnership(unresolvedThreadId).then((owner) => owner === "external" ? sendBridged() : sendDirect(), (error51) => {
         if ((method === "thread/read" || method === "thread/resume") && isUnsupportedPosixBridgeSpawn(error51)) {
@@ -22916,7 +23014,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         throw error51;
       });
     }
-    return shouldUseBridge(method, routedParameters) ? sendBridged() : sendDirect();
+    return shouldUseBridge(method, parameters) ? sendBridged() : sendDirect();
   };
   const publishDraftWorkspace = (parameters) => {
     if (!isRecord19(parameters) || parameters.ephemeral === true)
@@ -22945,10 +23043,10 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     for (const threadId2 of externalPrewarms)
       discardExternalPrewarm(threadId2);
   };
+  const restoreConsumption = isolateConsumption(manager, discardExternalPrewarm);
   const routedPrewarm = (parameters, options2) => {
-    const routed = routeThreadStart(parameters);
-    const external = isRecord19(routed) && routed.ephemeral !== true && typeof routed.model === "string" && routed.model.startsWith("codexhost/");
-    const routedParameters = external ? { ...routed, codexhostPrewarm: true } : routed;
+    const external = isRecord19(parameters) && parameters.ephemeral !== true && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
+    const routedParameters = external ? { ...parameters, codexhostPrewarm: true } : parameters;
     const generation = prewarmGeneration;
     publishDraftWorkspace(routedParameters);
     const pending = shouldUseBridge("thread/start", routedParameters) ? routedSend("thread/start", routedParameters, options2) : options2 === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options2);
@@ -23004,6 +23102,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
   const policy = Object.freeze({
     state: "ready",
     hostId: hostId2,
+    scopedCreation: restoreConsumption !== null,
     owns(candidateManager, candidate, candidateHostId, candidatePrewarmedThreadManager, requiresCurrentManager) {
       return !disposed && candidateManager === manager && candidate === bridge && candidateHostId === hostId2 && candidatePrewarmedThreadManager === prewarmedThreadManager && requiresCurrentManager === !!isCurrentManager;
     },
@@ -23012,12 +23111,13 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         throw new Error("Renderer request manager is retired");
       return manager;
     },
-    select(model2) {
+    select(model2, draftId, creationModes) {
       if (disposed || isCurrentManager && !isCurrentManager())
         throw new Error("Renderer request manager is retired");
       if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
         throw new Error("Draft route Model must be a codexhost transport carrier");
       }
+      restoreConsumption?.selectDraft(draftId, model2, creationModes);
       if (selectedModel === model2)
         return false;
       selectedModel = model2;
@@ -23040,6 +23140,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       disposed = true;
       prewarmGeneration += 1;
       retireResponses();
+      restoreConsumption?.dispose();
       if (bridge.sendRequest === routedSend)
         bridge.sendRequest = originalSend;
       if (bridge.prewarmThreadStart === routedPrewarm) {
@@ -23077,14 +23178,14 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
 
 // packages/desktop-control/dist/renderer-host-discovery.js
 function requestManagerFromHookState(value2, hostId2) {
-  const record4 = (candidate) => typeof candidate === "object" && candidate !== null;
+  const record5 = (candidate) => typeof candidate === "object" && candidate !== null;
   const manager = (candidate) => {
-    if (!record4(candidate) || !record4(candidate.requestClient) || !record4(candidate.prewarmedThreadManager))
+    if (!record5(candidate) || !record5(candidate.requestClient) || !record5(candidate.prewarmedThreadManager))
       return null;
     const bridge = candidate.requestClient;
     return typeof candidate.sendRequest === "function" && typeof bridge.sendRequest === "function" && typeof bridge.prewarmThreadStart === "function" && typeof bridge.enqueueRequest === "function" && typeof candidate.prewarmedThreadManager.discardAllPrewarmedThreads === "function" ? candidate : null;
   };
-  if (!record4(value2))
+  if (!record5(value2))
     return null;
   const direct = manager(value2) ?? manager(value2.manager);
   if (direct)
@@ -23288,6 +23389,372 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
   return routing;
 }
 
+// packages/desktop-control/dist/renderer-host-rpc-discovery.js
+function findRendererAppScopeStore(root) {
+  const MAX_VISITED_FIBERS = 5e4;
+  const record5 = (value2) => typeof value2 === "object" && value2 !== null;
+  const container = root.getElementById?.("root");
+  if (!record5(container))
+    return null;
+  const key = Object.getOwnPropertyNames(container).find((name) => name.startsWith("__reactContainer$"));
+  const first = key ? container[key] : null;
+  if (!record5(first))
+    return null;
+  const isScopeHandle = (value2) => record5(value2) && record5(value2.node) && "chain" in value2 && "scope" in value2 && typeof value2.get === "function" && typeof value2.set === "function" && typeof value2.watch === "function";
+  const stack = [first];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length && seen.size < MAX_VISITED_FIBERS) {
+    const fiber = stack.pop();
+    if (seen.has(fiber))
+      continue;
+    seen.add(fiber);
+    let hook = fiber.memoizedState;
+    for (let index = 0; record5(hook) && "next" in hook && index < 150; index += 1) {
+      const state = hook.memoizedState;
+      const handle = record5(state) ? state.current : null;
+      if (isScopeHandle(handle)) {
+        let node = handle.node;
+        const nodes = /* @__PURE__ */ new Set();
+        while (record5(node.parent) && !nodes.has(node.parent)) {
+          nodes.add(node);
+          node = node.parent;
+        }
+        const bindings = node.familyBindings;
+        return record5(bindings) && typeof bindings.get === "function" && typeof bindings.entries === "function" ? node : null;
+      }
+      hook = hook.next;
+    }
+    if (record5(fiber.sibling))
+      stack.push(fiber.sibling);
+    if (record5(fiber.child))
+      stack.push(fiber.child);
+  }
+  return null;
+}
+function findRendererHostRpcFamily(store) {
+  const record5 = (value2) => typeof value2 === "object" && value2 !== null;
+  const families = /* @__PURE__ */ new Set();
+  for (const [definition, members] of store.familyBindings) {
+    if (!record5(definition) || definition.kind !== "signal-family")
+      continue;
+    if (!record5(members) || typeof members.get !== "function")
+      continue;
+    for (const [hostId2, member] of members) {
+      if (typeof hostId2 !== "string" || !record5(member))
+        continue;
+      const signal = member.value;
+      if (!record5(signal) || typeof signal.get !== "function")
+        continue;
+      let value2;
+      try {
+        value2 = signal.get();
+      } catch {
+        continue;
+      }
+      if (record5(value2) && Object.keys(value2).length === 2 && typeof value2.status === "string" && record5(value2.client) && value2.client.hostId === hostId2 && "rpc" in value2.client) {
+        families.add(members);
+        break;
+      }
+    }
+  }
+  if (families.size !== 1)
+    return null;
+  return { store, family: families.values().next().value };
+}
+function resolveRendererHostRpc(discovery, hostId2) {
+  const record5 = (value3) => typeof value3 === "object" && value3 !== null;
+  const signal = discovery.family.get(hostId2)?.value;
+  if (!record5(signal) || typeof signal.get !== "function")
+    return null;
+  let value2;
+  try {
+    value2 = signal.get();
+  } catch {
+    return null;
+  }
+  if (!record5(value2) || value2.status !== "ready" || !record5(value2.client) || value2.client.hostId !== hostId2)
+    return null;
+  const rpc = value2.client.rpc;
+  return typeof rpc === "function" || record5(rpc) ? rpc : null;
+}
+function rendererHostRpcHostIds(discovery) {
+  return [...discovery.family.keys()].filter((hostId2) => typeof hostId2 === "string");
+}
+
+// packages/desktop-control/dist/renderer-host-rpc-routing.js
+function installRendererHostRpcRouting(root, target, dependencies2) {
+  const existing = target.__codexhostHostRoutingV1;
+  if (existing)
+    return existing;
+  let disposed = false;
+  let discovery = null;
+  const routes = /* @__PURE__ */ new Map();
+  const read = () => {
+    if (disposed)
+      return null;
+    if (!discovery) {
+      const store = dependencies2.findStore(root);
+      discovery = store ? dependencies2.findFamily(store) : null;
+    }
+    return discovery;
+  };
+  if (!read())
+    return null;
+  const isRecord19 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+  const externalDrafts = /* @__PURE__ */ new Map();
+  const selectedModels = /* @__PURE__ */ new Map();
+  const prewarmCarrier = (carrier) => {
+    const prefix = "codexhost/plugin-v1@";
+    if (!carrier.startsWith(prefix))
+      return null;
+    try {
+      const json2 = carrier.slice(prefix.length).replace(/[a-f0-9]{2}/gu, (byte) => String.fromCharCode(Number.parseInt(byte, 16)));
+      const route = JSON.parse(json2);
+      if (!isRecord19(route))
+        return null;
+      const payload = [...JSON.stringify({ ...route, prewarm: true })].map((character) => character.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+      return `${prefix}${payload}`;
+    } catch {
+      return null;
+    }
+  };
+  const publishDraftWorkspace = (hostId2, cwd) => {
+    if (typeof cwd !== "string" || cwd.length === 0)
+      return;
+    const drafts = isRecord19(target.__codexhostDraftWorkspacesV1) ? target.__codexhostDraftWorkspacesV1 : {};
+    if (drafts[hostId2] === cwd)
+      return;
+    drafts[hostId2] = cwd;
+    Object.defineProperty(target, "__codexhostDraftWorkspacesV1", {
+      configurable: true,
+      value: drafts
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(new CustomEvent("codexhost:draft-workspace", { detail: { hostId: hostId2, cwd } }));
+    }
+  };
+  const routeCreationCall = (message2) => {
+    if (!Array.isArray(message2) || message2.length !== 2 || message2[0] !== "push")
+      return message2;
+    const expression = message2[1];
+    if (!Array.isArray(expression) || expression.length !== 4 || expression[0] !== "pipeline")
+      return message2;
+    const [, importId, path43, args] = expression;
+    if (!Array.isArray(path43) || path43.length !== 1 || !Array.isArray(args))
+      return message2;
+    const [input, options2] = args;
+    if (!isRecord19(input) || !isRecord19(input.collaborationMode))
+      return message2;
+    const settings = input.collaborationMode.settings;
+    if (!isRecord19(settings))
+      return message2;
+    let model2 = null;
+    if (path43[0] === "startConversation") {
+      const draftId = isRecord19(options2) ? options2.clientThreadId : null;
+      model2 = typeof draftId === "string" ? externalDrafts.get(draftId)?.model ?? null : null;
+    } else if (path43[0] === "prewarmConversation") {
+      if (input.ephemeral !== true)
+        publishDraftWorkspace("local", input.cwd);
+      const selected = selectedModels.get("local");
+      model2 = selected ? prewarmCarrier(selected) : null;
+    }
+    if (!model2)
+      return message2;
+    return [
+      "push",
+      [
+        "pipeline",
+        importId,
+        path43,
+        [
+          {
+            ...input,
+            collaborationMode: { ...input.collaborationMode, settings: { ...settings, model: model2 } }
+          },
+          ...args.slice(1)
+        ]
+      ]
+    ];
+  };
+  const port = dependencies2.portPrototype;
+  const originalPostMessage = port.postMessage;
+  const postMessage = function(message2, ...rest) {
+    let routed = message2;
+    try {
+      routed = disposed ? message2 : routeCreationCall(message2);
+    } catch {
+      routed = message2;
+    }
+    return originalPostMessage.call(this, routed, ...rest);
+  };
+  port.postMessage = postMessage;
+  const createRoute = (hostId2, rpc) => {
+    let retired = false;
+    const isCurrent = () => !retired && !disposed && routes.get(hostId2)?.rpc === rpc;
+    const manager = Object.freeze({
+      kind: "main-process-rpc",
+      getHostId: () => hostId2,
+      sendRequest(method, params, options2) {
+        if (!isCurrent())
+          return Promise.reject(new Error(`Renderer request manager is retired for ${hostId2}`));
+        return options2 === void 0 ? rpc.sendRequest(method, params) : rpc.sendRequest(method, params, options2);
+      },
+      // The main process broadcasts every app-server notification to its windows,
+      // including codexhost methods Desktop's own notification table drops.
+      addNotificationCallback(methods, listener) {
+        const accepted = new Set(typeof methods === "string" ? [methods] : methods);
+        const onMessage = (event) => {
+          const { source, data } = event;
+          if (source != null && source !== target)
+            return;
+          if (!isRecord19(data) || data.type !== "mcp-notification" || data.hostId !== hostId2 || typeof data.method !== "string" || !accepted.has(data.method) || !isCurrent())
+            return;
+          listener({ method: data.method, params: data.params });
+        };
+        target.addEventListener?.("message", onMessage);
+        return () => target.removeEventListener?.("message", onMessage);
+      }
+    });
+    const clearDrafts = () => {
+      for (const [draftId, draft] of externalDrafts) {
+        if (draft.owner === policy)
+          externalDrafts.delete(draftId);
+      }
+    };
+    const clear = () => isCurrent() ? Promise.resolve(rpc.clearPrewarmedThreads()).then(() => void 0) : Promise.reject(new Error("Renderer request manager is retired"));
+    const policy = Object.freeze({
+      state: "ready",
+      hostId: hostId2,
+      scopedCreation: true,
+      requestTarget: () => {
+        if (!isCurrent())
+          throw new Error("Renderer request manager is retired");
+        return manager;
+      },
+      select(model2, draftId) {
+        if (!isCurrent())
+          throw new Error("Renderer request manager is retired");
+        if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
+          throw new Error("Draft route Model must be a codexhost transport carrier");
+        }
+        if (draftId === void 0) {
+          if (model2 === null)
+            clearDrafts();
+        } else if (model2 === null) {
+          if (externalDrafts.get(draftId)?.owner === policy)
+            externalDrafts.delete(draftId);
+        } else {
+          if (!draftId.startsWith("client-new-thread:"))
+            throw new Error("External draft route is missing its client Thread identity");
+          externalDrafts.set(draftId, { model: model2, owner: policy });
+        }
+        if ((selectedModels.get(hostId2) ?? null) === model2)
+          return false;
+        if (model2 === null)
+          selectedModels.delete(hostId2);
+        else
+          selectedModels.set(hostId2, model2);
+        void clear().catch(() => void 0);
+        return true;
+      },
+      clear,
+      dispose() {
+        if (retired)
+          return;
+        retired = true;
+        clearDrafts();
+        selectedModels.delete(hostId2);
+      }
+    });
+    return { hostId: hostId2, manager, policy };
+  };
+  const retire = (hostId2) => {
+    const entry = routes.get(hostId2);
+    routes.delete(hostId2);
+    entry?.route.policy.dispose();
+  };
+  const routeFor = (hostId2) => {
+    const current = read();
+    const rpc = current ? dependencies2.resolve(current, hostId2) : null;
+    const previous = routes.get(hostId2);
+    if (rpc && previous?.rpc === rpc)
+      return previous.route;
+    retire(hostId2);
+    if (!rpc)
+      return null;
+    const route = createRoute(hostId2, rpc);
+    routes.set(hostId2, { route, rpc });
+    return route;
+  };
+  const publish = (route) => {
+    const policy = route?.policy;
+    if (target.__codexhostDraftPrewarmPolicyV1 === policy)
+      return;
+    Object.defineProperty(target, "__codexhostDraftPrewarmPolicyV1", {
+      configurable: true,
+      value: policy
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(new CustomEvent("codexhost:draft-prewarm-policy-changed"));
+    }
+  };
+  const composerHostId = (composer) => {
+    const hostIds = new Set(dependencies2.composerHostIds(composer).hostIds);
+    const hostId2 = hostIds.size === 1 ? hostIds.values().next().value : null;
+    return typeof hostId2 === "string" && hostId2 ? hostId2 : null;
+  };
+  const routing = {
+    knownHostIds() {
+      const current = read();
+      return current ? dependencies2.hostIds(current) : [];
+    },
+    forHost(hostId2) {
+      return hostId2 && !disposed ? routeFor(hostId2) : null;
+    },
+    hostIdForComposer(composer) {
+      if (disposed)
+        return null;
+      try {
+        return composerHostId(composer);
+      } catch {
+        return null;
+      }
+    },
+    forComposer(composer) {
+      if (disposed)
+        return null;
+      let hostId2;
+      try {
+        hostId2 = composerHostId(composer);
+      } catch {
+        hostId2 = null;
+      }
+      const route = hostId2 ? routeFor(hostId2) : null;
+      if (!composer)
+        publish(route);
+      return route;
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const hostId2 of [...routes.keys()])
+        retire(hostId2);
+      discovery = null;
+      externalDrafts.clear();
+      selectedModels.clear();
+      if (port.postMessage === postMessage)
+        port.postMessage = originalPostMessage;
+      if (target.__codexhostHostRoutingV1 === routing) {
+        delete target.__codexhostHostRoutingV1;
+        publish(null);
+      }
+    }
+  };
+  Object.defineProperty(target, "__codexhostHostRoutingV1", { configurable: true, value: routing });
+  return routing;
+}
+
 // packages/desktop-control/dist/renderer-draft-prewarm-policy.js
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
@@ -23299,14 +23766,41 @@ function directRendererInstaller() {
     const resolveRendererHostManager = ${resolveRendererHostManager.toString()};
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
-    const routing = (${installRendererHostRouting.toString()})(
-      document, window,
-      (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
+    const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
+    const discover = (root) =>
+      discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState);
+    const installNative = () => (${installRendererHostRouting.toString()})(
+      document, window, discover,
       (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
       (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
+        isolateRendererPrewarmConsumption,
       ),
     );
+    const installRpc = () => typeof MessagePort !== 'function' ? null : (${installRendererHostRpcRouting.toString()})(document, window, {
+      findStore: ${findRendererAppScopeStore.toString()},
+      findFamily: ${findRendererHostRpcFamily.toString()},
+      resolve: ${resolveRendererHostRpc.toString()},
+      hostIds: ${rendererHostRpcHostIds.toString()},
+      composerHostIds: (composer) => {
+        const source = composer?.matches?.('[data-codex-composer], [contenteditable="true"][role="textbox"]')
+          ? { querySelectorAll: () => [composer] }
+          : (composer ?? document);
+        return discover(source);
+      },
+      portPrototype: MessagePort.prototype,
+    });
+    // Desktop 26.1027 moved AppServerManagers to the main process. Older builds
+    // expose native managers in Renderer hook state; the main-process mode only
+    // applies when none is visible and its per-Host RPC store is identified.
+    const routing = (() => {
+      if (window.__codexhostHostRoutingV1) return window.__codexhostHostRoutingV1;
+      const native = discover(document);
+      if (native.managers.length || native.registries.length) return installNative();
+      const rpc = installRpc();
+      if (rpc) return rpc;
+      throw new Error('Renderer Host request manager is unavailable');
+    })();
     // Publish a default draft policy only when its Host is unambiguous. Host
     // connections can be ready even when multiple Composers coexist.
     const composerRoute = routing.forComposer();
@@ -23341,6 +23835,119 @@ function installRendererDraftPrewarmPolicyDirect(renderer) {
 // packages/desktop-control/dist/renderer-control-session.js
 var startupTraceStartedAt = Date.now();
 
+// packages/desktop-control/dist/renderer-loaded-modules.js
+var record3 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+var MAX_MODULES = 4096;
+function nativeModuleCatalogExpression(urls, complete, owner) {
+  return `Object.defineProperty(globalThis, '__codexhostLoadedModulesV1', {
+    configurable: true,
+    value: Object.freeze({ owner: ${JSON.stringify(owner)}, documentUrl: location.href, complete: ${complete}, urls: Object.freeze(${JSON.stringify(urls)}) })
+  }); void 0`;
+}
+async function installRendererLoadedModules(renderer) {
+  const owner = crypto.randomUUID();
+  const contexts = /* @__PURE__ */ new Map();
+  const contextIds = /* @__PURE__ */ new Map();
+  const dirty = /* @__PURE__ */ new Set();
+  let ready = false;
+  let disposed = false;
+  let timer;
+  let publishing = Promise.resolve();
+  const flush = () => {
+    clearTimeout(timer);
+    timer = void 0;
+    const pending = [...dirty];
+    dirty.clear();
+    publishing = publishing.catch(() => void 0).then(async () => {
+      for (const uniqueId of pending) {
+        const context = contexts.get(uniqueId);
+        if (!context || disposed)
+          continue;
+        const response = await renderer.command("Runtime.evaluate", {
+          expression: nativeModuleCatalogExpression([...context.urls], context.complete, owner),
+          uniqueContextId: uniqueId
+        });
+        if (record3(response) && record3(response.exceptionDetails))
+          throw new Error("Loaded Renderer module catalog publication failed");
+      }
+    });
+    return publishing;
+  };
+  const schedule = (uniqueId) => {
+    dirty.add(uniqueId);
+    if (ready && timer === void 0)
+      timer = setTimeout(() => {
+        void flush().catch((error51) => {
+          console.error("Could not publish loaded Renderer modules", error51);
+        });
+      }, 10);
+  };
+  const remove = (id2) => {
+    const uniqueId = contextIds.get(id2);
+    contextIds.delete(id2);
+    if (uniqueId) {
+      contexts.delete(uniqueId);
+      dirty.delete(uniqueId);
+    }
+  };
+  const listeners = [
+    renderer.on("Runtime.executionContextCreated", (params) => {
+      const context = record3(params) ? params.context : null;
+      if (!record3(context) || typeof context.id !== "number" || typeof context.uniqueId !== "string" || !record3(context.auxData) || context.auxData.isDefault !== true)
+        return;
+      contextIds.set(context.id, context.uniqueId);
+      contexts.set(context.uniqueId, { urls: /* @__PURE__ */ new Set(), complete: true });
+      schedule(context.uniqueId);
+    }),
+    renderer.on("Runtime.executionContextDestroyed", (params) => {
+      if (record3(params) && typeof params.executionContextId === "number")
+        remove(params.executionContextId);
+    }),
+    renderer.on("Runtime.executionContextsCleared", () => {
+      contextIds.clear();
+      contexts.clear();
+      dirty.clear();
+    }),
+    renderer.on("Debugger.scriptParsed", (params) => {
+      if (!record3(params) || params.isModule !== true || params.hasSourceURL === true || typeof params.url !== "string" || typeof params.executionContextId !== "number")
+        return;
+      const uniqueId = contextIds.get(params.executionContextId);
+      const context = uniqueId ? contexts.get(uniqueId) : null;
+      if (!context || !uniqueId || context.urls.has(params.url))
+        return;
+      if (context.urls.size >= MAX_MODULES)
+        context.complete = false;
+      else
+        context.urls.add(params.url);
+      schedule(uniqueId);
+    })
+  ];
+  const dispose = () => {
+    disposed = true;
+    clearTimeout(timer);
+    for (const unsubscribe of listeners)
+      unsubscribe();
+    for (const uniqueId of contexts.keys())
+      void renderer.command("Runtime.evaluate", {
+        expression: `if (globalThis.__codexhostLoadedModulesV1 === undefined || globalThis.__codexhostLoadedModulesV1?.owner === ${JSON.stringify(owner)}) { ${nativeModuleCatalogExpression([], false, owner)} }`,
+        uniqueContextId: uniqueId
+      }).catch(() => void 0);
+    contexts.clear();
+    contextIds.clear();
+    dirty.clear();
+  };
+  try {
+    await renderer.command("Runtime.enable");
+    await renderer.command("Debugger.enable");
+    ready = true;
+    await flush();
+    return dispose;
+  } catch (error51) {
+    dispose();
+    throw error51;
+  }
+}
+
 // packages/desktop-control/dist/renderer-cdp-control-session.js
 function isRecord2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -23475,15 +24082,17 @@ async function waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs
 }
 async function installTarget(target, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations) {
   const renderer = await operations.connect(target.webSocketDebuggerUrl);
+  let disposeModules;
   try {
-    await renderer.command("Runtime.enable");
+    disposeModules = await installRendererLoadedModules(renderer);
     await renderer.command("Page.enable");
     await renderer.command("Page.addScriptToEvaluateOnNewDocument", { source: rendererSource });
     await evaluateSource(renderer, rendererSource);
     const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(renderer);
     const binding = await waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs);
-    return { renderer, snapshot: { target, draftPrewarmPolicy, binding } };
+    return { renderer, snapshot: { target, draftPrewarmPolicy, binding }, disposeModules };
   } catch (error51) {
+    disposeModules?.();
     renderer.close();
     throw error51;
   }
@@ -23497,8 +24106,9 @@ var InstalledRendererCdpControlSession = class {
   pollIntervalMs;
   operations;
   currentSnapshot;
+  disposeModules;
   #closed = false;
-  constructor(renderer, rendererCdpEndpoint, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot) {
+  constructor(renderer, rendererCdpEndpoint, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot, disposeModules) {
     this.renderer = renderer;
     this.rendererCdpEndpoint = rendererCdpEndpoint;
     this.rendererSource = rendererSource;
@@ -23507,6 +24117,7 @@ var InstalledRendererCdpControlSession = class {
     this.pollIntervalMs = pollIntervalMs;
     this.operations = operations;
     this.currentSnapshot = currentSnapshot;
+    this.disposeModules = disposeModules;
   }
   get snapshot() {
     return this.currentSnapshot;
@@ -23517,8 +24128,10 @@ var InstalledRendererCdpControlSession = class {
     const target = await waitForPrimaryTarget(this.rendererCdpEndpoint, this.operations, this.timeoutMs, this.pollIntervalMs, this.currentSnapshot.target.id);
     if (target.id !== this.currentSnapshot.target.id) {
       const replacement = await installTarget(target, this.rendererSource, this.enabledAgents, this.timeoutMs, this.pollIntervalMs, this.operations);
+      this.disposeModules();
       this.renderer.close();
       this.renderer = replacement.renderer;
+      this.disposeModules = replacement.disposeModules;
       this.currentSnapshot = replacement.snapshot;
       return this.currentSnapshot;
     }
@@ -23532,8 +24145,10 @@ var InstalledRendererCdpControlSession = class {
       return this.currentSnapshot;
     } catch {
       const replacement = await installTarget(target, this.rendererSource, this.enabledAgents, this.timeoutMs, this.pollIntervalMs, this.operations);
+      this.disposeModules();
       this.renderer.close();
       this.renderer = replacement.renderer;
+      this.disposeModules = replacement.disposeModules;
       this.currentSnapshot = replacement.snapshot;
       return this.currentSnapshot;
     }
@@ -23553,6 +24168,7 @@ var InstalledRendererCdpControlSession = class {
     if (this.#closed)
       return;
     this.#closed = true;
+    this.disposeModules();
     this.renderer.close();
   }
 };
@@ -23568,7 +24184,7 @@ async function createRendererCdpControlSession(options2) {
   const operations = options2.operations ?? defaultOperations;
   const target = await waitForPrimaryTarget(options2.rendererCdpEndpoint, operations, timeoutMs, pollIntervalMs, void 0, options2.signal);
   const installed = await installTarget(target, options2.rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations);
-  return new InstalledRendererCdpControlSession(installed.renderer, options2.rendererCdpEndpoint, options2.rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, installed.snapshot);
+  return new InstalledRendererCdpControlSession(installed.renderer, options2.rendererCdpEndpoint, options2.rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, installed.snapshot, installed.disposeModules);
 }
 function installRendererCdpControlSession(options2) {
   return createRendererCdpControlSession(options2);
@@ -25653,15 +26269,15 @@ var storedThreadMetadataV1Schema = external_exports.object({
   hostThreadId: storedHostThreadIdSchema,
   ...storedThreadMetadataFieldsShape
 }).passthrough();
-function refineThreadRecord(record4, context) {
-  if (record4.state === "ready" && !record4.nativeSessionRef) {
+function refineThreadRecord(record5, context) {
+  if (record5.state === "ready" && !record5.nativeSessionRef) {
     context.addIssue({
       code: "custom",
       path: ["nativeSessionRef"],
       message: "Ready Thread must have a Native Session Ref"
     });
   }
-  if (record4.nativeSessionRef && record4.nativeSessionRef.harnessId !== record4.harnessId) {
+  if (record5.nativeSessionRef && record5.nativeSessionRef.harnessId !== record5.harnessId) {
     context.addIssue({
       code: "custom",
       path: ["nativeSessionRef", "harnessId"],
@@ -25670,7 +26286,7 @@ function refineThreadRecord(record4, context) {
   }
   const hostTurnIds = /* @__PURE__ */ new Set();
   const nativeTurnKeys = /* @__PURE__ */ new Set();
-  for (const [index, mapping] of record4.turnMappings.entries()) {
+  for (const [index, mapping] of record5.turnMappings.entries()) {
     if (hostTurnIds.has(mapping.hostTurnId)) {
       context.addIssue({
         code: "custom",
@@ -25694,14 +26310,14 @@ function refineThreadRecord(record4, context) {
     ]) {
       if (!ref)
         continue;
-      if (ref.harnessId !== record4.harnessId) {
+      if (ref.harnessId !== record5.harnessId) {
         context.addIssue({
           code: "custom",
           path: ["turnMappings", index, name, "harnessId"],
           message: "Turn Ref Harness must match the Thread Harness"
         });
       }
-      if (record4.nativeSessionRef && ref.nativeSessionId !== record4.nativeSessionRef.nativeSessionId) {
+      if (record5.nativeSessionRef && ref.nativeSessionId !== record5.nativeSessionRef.nativeSessionId) {
         context.addIssue({
           code: "custom",
           path: ["turnMappings", index, name, "nativeSessionId"],
@@ -25733,7 +26349,7 @@ var storedDelegationRecordV1Schema = external_exports.object({
   taskDigest: external_exports.string().regex(/^[a-f0-9]{64}$/u),
   createdAt: isoDateSchema,
   updatedAt: isoDateSchema
-}).strict().refine((record4) => record4.parentHostThreadId !== record4.childHostThreadId, {
+}).strict().refine((record5) => record5.parentHostThreadId !== record5.childHostThreadId, {
   path: ["childHostThreadId"],
   message: "Delegation child Thread must differ from its parent"
 });
@@ -25873,8 +26489,8 @@ var MappingStoreError = class extends Error {
     this.name = "MappingStoreError";
   }
 };
-function cloneRecord(record4) {
-  return JSON.parse(JSON.stringify(record4));
+function cloneRecord(record5) {
+  return JSON.parse(JSON.stringify(record5));
 }
 function nativeSessionKey(ref) {
   return `${ref.harnessId}\0${ref.nativeSessionId}`;
@@ -25917,22 +26533,22 @@ function withoutUnparsedUrlCredentials(value2) {
   const kept = keepUser && !userInfo.includes(":") ? `${userInfo}@` : "";
   return value2.slice(0, authorityStart) + kept + value2.slice(authorityStart + at + 1);
 }
-function threadMetadataOf(record4) {
-  const fields = Object.fromEntries(THREAD_METADATA_FIELDS.filter((name) => record4[name] !== void 0).map((name) => [
+function threadMetadataOf(record5) {
+  const fields = Object.fromEntries(THREAD_METADATA_FIELDS.filter((name) => record5[name] !== void 0).map((name) => [
     name,
-    record4[name]
+    record5[name]
   ]));
   if (Object.keys(fields).length === 0)
     return null;
-  return { formatVersion: 1, hostThreadId: record4.hostThreadId, ...fields };
+  return { formatVersion: 1, hostThreadId: record5.hostThreadId, ...fields };
 }
-function withoutThreadMetadata(record4) {
-  const { projectId, daybreakEnabled, gitInfo, ...core } = record4;
+function withoutThreadMetadata(record5) {
+  const { projectId, daybreakEnabled, gitInfo, ...core } = record5;
   void [projectId, daybreakEnabled, gitInfo];
   return core;
 }
-function withThreadMetadata(record4, metadata) {
-  const core = withoutThreadMetadata(record4);
+function withThreadMetadata(record5, metadata) {
+  const core = withoutThreadMetadata(record5);
   for (const name of THREAD_METADATA_FIELDS) {
     if (metadata[name] !== void 0)
       Object.assign(core, { [name]: metadata[name] });
@@ -26117,13 +26733,13 @@ var MappingStore = class {
       for (const name of names) {
         const primary = path18.join(this.#threadsDirectory, name);
         const backup = path18.join(this.#backupsDirectory, name);
-        let record4 = null;
+        let record5 = null;
         try {
-          record4 = await this.#readRecord(primary, name);
+          record5 = await this.#readRecord(primary, name);
         } catch (primaryError) {
           try {
-            record4 = await this.#readRecord(backup, name);
-            await this.#replaceFile(primary, record4, false);
+            record5 = await this.#readRecord(backup, name);
+            await this.#replaceFile(primary, record5, false);
           } catch (backupError) {
             const quarantine = path18.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
             await rename10(primary, quarantine).catch(() => void 0);
@@ -26132,20 +26748,20 @@ var MappingStore = class {
             continue;
           }
         }
-        if (record4.state === "creating" && !record4.nativeSessionRef) {
+        if (record5.state === "creating" && !record5.nativeSessionRef) {
           await rm10(primary, { force: true });
           await rm10(backup, { force: true });
-          await rm10(this.#metadataPath(record4.hostThreadId), { force: true });
+          await rm10(this.#metadataPath(record5.hostThreadId), { force: true });
           continue;
         }
-        const metadata = await this.#readMetadata(record4.hostThreadId);
+        const metadata = await this.#readMetadata(record5.hostThreadId);
         if (metadata) {
-          record4 = withThreadMetadata(record4, metadata);
-        } else if (threadMetadataOf(record4)) {
-          await this.#writeMetadataFile(record4.hostThreadId, threadMetadataOf(record4));
-          await this.#replaceFile(primary, record4, false);
+          record5 = withThreadMetadata(record5, metadata);
+        } else if (threadMetadataOf(record5)) {
+          await this.#writeMetadataFile(record5.hostThreadId, threadMetadataOf(record5));
+          await this.#replaceFile(primary, record5, false);
         }
-        this.#records.set(record4.hostThreadId, record4);
+        this.#records.set(record5.hostThreadId, record5);
       }
       await Promise.all((await readdir4(this.#metadataDirectory)).filter((name) => name.endsWith(".json") && !this.#records.has(name.slice(0, -5))).map((name) => rm10(path18.join(this.#metadataDirectory, name), { force: true })));
       const delegationNames = (await readdir4(this.#delegationsDirectory)).filter((name) => name.endsWith(".json"));
@@ -26182,8 +26798,8 @@ var MappingStore = class {
   }
   async getThread(hostThreadId) {
     this.#requireInitialized();
-    const record4 = this.#records.get(hostThreadId);
-    return record4 ? cloneRecord(record4) : null;
+    const record5 = this.#records.get(hostThreadId);
+    return record5 ? cloneRecord(record5) : null;
   }
   async listThreads() {
     this.#requireInitialized();
@@ -26196,8 +26812,8 @@ var MappingStore = class {
   }
   async getDelegation(delegationId) {
     this.#requireInitialized();
-    const record4 = this.#delegations.get(delegationId);
-    return record4 ? cloneRecord(record4) : null;
+    const record5 = this.#delegations.get(delegationId);
+    return record5 ? cloneRecord(record5) : null;
   }
   async getDelegationByChild(childHostThreadId) {
     this.#requireInitialized();
@@ -26211,12 +26827,12 @@ var MappingStore = class {
   }
   async listDelegations(parentHostThreadId) {
     this.#requireInitialized();
-    return [...this.#delegations.values()].filter((record4) => !parentHostThreadId || record4.parentHostThreadId === parentHostThreadId).map(cloneRecord);
+    return [...this.#delegations.values()].filter((record5) => !parentHostThreadId || record5.parentHostThreadId === parentHostThreadId).map(cloneRecord);
   }
   async findRecentDelegation(input) {
     this.#requireInitialized();
     const threshold = input.since.getTime();
-    const found = [...this.#delegations.values()].filter((record4) => record4.parentHostThreadId === input.parentHostThreadId && record4.targetHarnessId === input.targetHarnessId && record4.taskDigest === input.taskDigest && Date.parse(record4.createdAt) >= threshold).toSorted((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
+    const found = [...this.#delegations.values()].filter((record5) => record5.parentHostThreadId === input.parentHostThreadId && record5.targetHarnessId === input.targetHarnessId && record5.taskDigest === input.taskDigest && Date.parse(record5.createdAt) >= threshold).toSorted((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return found ? cloneRecord(found) : null;
   }
   async createDelegation(input) {
@@ -26231,7 +26847,7 @@ var MappingStore = class {
       throw new MappingStoreError("DUPLICATE_CREATE_REQUEST", "Delegation Request ID already exists");
     }
     const timestamp = this.#now().toISOString();
-    const record4 = storedDelegationRecordV1Schema.parse({
+    const record5 = storedDelegationRecordV1Schema.parse({
       formatVersion: 1,
       revision: 1,
       ...input,
@@ -26239,10 +26855,10 @@ var MappingStore = class {
       createdAt: timestamp,
       updatedAt: timestamp
     });
-    await this.#replaceDelegationFile(record4);
-    this.#delegations.set(record4.delegationId, record4);
+    await this.#replaceDelegationFile(record5);
+    this.#delegations.set(record5.delegationId, record5);
     this.#rebuildIndexes();
-    return cloneRecord(record4);
+    return cloneRecord(record5);
   }
   async setDelegationStatus(delegationId, status2) {
     this.#requireInitialized();
@@ -26293,7 +26909,7 @@ var MappingStore = class {
         throw new MappingStoreError("DUPLICATE_THREAD_ID", "Host Thread ID already exists");
       }
       const timestamp = this.#now().toISOString();
-      const record4 = storedThreadRecordV1Schema.parse({
+      const record5 = storedThreadRecordV1Schema.parse({
         formatVersion: 1,
         revision: 1,
         hostThreadId: input.hostThreadId,
@@ -26312,8 +26928,8 @@ var MappingStore = class {
         createdAt: timestamp,
         updatedAt: timestamp
       });
-      await this.#writeNew(record4);
-      result = cloneRecord(record4);
+      await this.#writeNew(record5);
+      result = cloneRecord(record5);
     });
     if (!result)
       throw new MappingStoreError("IO_ERROR", "Provisional create produced no result");
@@ -26484,8 +27100,8 @@ var MappingStore = class {
   async removeProvisional(hostThreadId) {
     this.#requireInitialized();
     await this.#enqueue(async () => {
-      const record4 = this.#records.get(hostThreadId);
-      if (record4?.state === "ready") {
+      const record5 = this.#records.get(hostThreadId);
+      if (record5?.state === "ready") {
         throw new MappingStoreError("MAPPING_CONFLICT", "Ready Thread cannot be removed as provisional");
       }
       await this.#remove(hostThreadId);
@@ -26523,13 +27139,17 @@ var MappingStore = class {
     await this.#enqueue(() => this.#remove(hostThreadId));
   }
   async #remove(hostThreadId) {
-    if (!this.#records.has(hostThreadId))
+    const current = this.#records.get(hostThreadId);
+    if (!current)
       return;
-    await Promise.all([
-      rm10(this.#recordPath(hostThreadId), { force: true }),
-      rm10(this.#backupPath(hostThreadId), { force: true }),
-      rm10(this.#metadataPath(hostThreadId), { force: true })
-    ]);
+    await rm10(this.#recordPath(hostThreadId), { force: true });
+    try {
+      await rm10(this.#backupPath(hostThreadId), { force: true });
+      await rm10(this.#metadataPath(hostThreadId), { force: true });
+    } catch (error51) {
+      await this.#replaceFile(this.#recordPath(hostThreadId), current, false);
+      throw error51;
+    }
     this.#records.delete(hostThreadId);
     this.#rebuildIndexes();
   }
@@ -26612,25 +27232,25 @@ var MappingStore = class {
     }
     return merged;
   }
-  async #writeNew(record4) {
-    this.#validateGlobal(record4, null);
-    await this.#replaceFile(this.#recordPath(record4.hostThreadId), record4, false);
-    this.#records.set(record4.hostThreadId, record4);
+  async #writeNew(record5) {
+    this.#validateGlobal(record5, null);
+    await this.#replaceFile(this.#recordPath(record5.hostThreadId), record5, false);
+    this.#records.set(record5.hostThreadId, record5);
     this.#rebuildIndexes();
   }
-  async #replaceFile(target, record4, preserveBackup) {
+  async #replaceFile(target, record5, preserveBackup) {
     const temp = `${target}.tmp-${randomUUID9()}`;
     let handle = null;
     try {
-      await this.#beforeReplace?.(cloneRecord(record4));
+      await this.#beforeReplace?.(cloneRecord(record5));
       handle = await open7(temp, "wx", constants3.S_IRUSR | constants3.S_IWUSR);
-      await handle.writeFile(`${JSON.stringify(withoutThreadMetadata(record4), null, 2)}
+      await handle.writeFile(`${JSON.stringify(withoutThreadMetadata(record5), null, 2)}
 `, "utf8");
       await handle.sync();
       await handle.close();
       handle = null;
       if (preserveBackup && await exists(target)) {
-        await copyFile3(target, this.#backupPath(record4.hostThreadId));
+        await copyFile3(target, this.#backupPath(record5.hostThreadId));
       }
       await rename10(temp, target);
     } catch (error51) {
@@ -26691,13 +27311,13 @@ var MappingStore = class {
       return null;
     }
   }
-  async #replaceDelegationFile(record4) {
-    const target = this.#delegationPath(record4.delegationId);
+  async #replaceDelegationFile(record5) {
+    const target = this.#delegationPath(record5.delegationId);
     const temp = `${target}.tmp-${randomUUID9()}`;
     let handle = null;
     try {
       handle = await open7(temp, "wx", constants3.S_IRUSR | constants3.S_IWUSR);
-      await handle.writeFile(`${JSON.stringify(record4, null, 2)}
+      await handle.writeFile(`${JSON.stringify(record5, null, 2)}
 `, "utf8");
       await handle.sync();
       await handle.close();
@@ -26781,18 +27401,18 @@ var MappingStore = class {
       });
     }
   }
-  #validateGlobal(record4, replacing) {
-    const duplicateCreate = this.#createRequests.get(record4.createRequestId);
+  #validateGlobal(record5, replacing) {
+    const duplicateCreate = this.#createRequests.get(record5.createRequestId);
     if (duplicateCreate && duplicateCreate !== replacing) {
       throw new MappingStoreError("DUPLICATE_CREATE_REQUEST", "Create request is already stored");
     }
-    if (record4.nativeSessionRef && !record4.subagent) {
-      const duplicateSession = this.#nativeSessions.get(nativeSessionKey(record4.nativeSessionRef));
+    if (record5.nativeSessionRef && !record5.subagent) {
+      const duplicateSession = this.#nativeSessions.get(nativeSessionKey(record5.nativeSessionRef));
       if (duplicateSession && duplicateSession !== replacing) {
         throw new MappingStoreError("DUPLICATE_NATIVE_SESSION", "Native Session is already mapped");
       }
     }
-    for (const mapping of record4.turnMappings) {
+    for (const mapping of record5.turnMappings) {
       const duplicateHostTurn = this.#hostTurns.get(mapping.hostTurnId);
       if (duplicateHostTurn && duplicateHostTurn !== replacing) {
         throw new MappingStoreError("MAPPING_CONFLICT", "Host Turn is already mapped");
@@ -26822,14 +27442,14 @@ var MappingStore = class {
         this.#delegationRequests.set(delegation.requestId, delegation.delegationId);
       }
     }
-    for (const record4 of this.#records.values()) {
-      this.#validateGlobal(record4, record4.hostThreadId);
-      this.#createRequests.set(record4.createRequestId, record4.hostThreadId);
-      if (record4.nativeSessionRef && !record4.subagent) {
-        this.#nativeSessions.set(nativeSessionKey(record4.nativeSessionRef), record4.hostThreadId);
+    for (const record5 of this.#records.values()) {
+      this.#validateGlobal(record5, record5.hostThreadId);
+      this.#createRequests.set(record5.createRequestId, record5.hostThreadId);
+      if (record5.nativeSessionRef && !record5.subagent) {
+        this.#nativeSessions.set(nativeSessionKey(record5.nativeSessionRef), record5.hostThreadId);
       }
-      for (const mapping of record4.turnMappings) {
-        this.#hostTurns.set(mapping.hostTurnId, record4.hostThreadId);
+      for (const mapping of record5.turnMappings) {
+        this.#hostTurns.set(mapping.hostTurnId, record5.hostThreadId);
         this.#nativeTurns.set(nativeTurnKey(mapping), mapping.hostTurnId);
       }
     }
@@ -28260,16 +28880,16 @@ function planFromTodoValue(value2) {
         return fromText;
     }
   }
-  const record4 = unwrapToolRecord(value2);
-  if (!record4)
+  const record5 = unwrapToolRecord(value2);
+  if (!record5)
     return planFromChecklistText(typeof value2 === "string" ? value2 : null);
-  if (isRecord10(record4.TodosUpdated)) {
-    const nested = planFromTodoValue(record4.TodosUpdated);
+  if (isRecord10(record5.TodosUpdated)) {
+    const nested = planFromTodoValue(record5.TodosUpdated);
     if (nested)
       return nested;
   }
-  const explanation = nestedString(record4, ["explanation", "message", "summary"]) ?? null;
-  const list = coerceTodoList(record4.todos ?? record4.items ?? record4.plan ?? record4.tasks ?? record4.entries);
+  const explanation = nestedString(record5, ["explanation", "message", "summary"]) ?? null;
+  const list = coerceTodoList(record5.todos ?? record5.items ?? record5.plan ?? record5.tasks ?? record5.entries);
   if (!list || list.length === 0)
     return planFromChecklistText(explanation);
   const plan = [];
@@ -28299,8 +28919,8 @@ function coerceTodoList(value2) {
     const parsed2 = JSON.parse(trimmed);
     if (Array.isArray(parsed2))
       return parsed2;
-    const record4 = unwrapToolRecord(parsed2);
-    return record4 ? coerceTodoList(record4.todos ?? record4.items ?? record4.plan ?? record4.tasks ?? record4.entries) : null;
+    const record5 = unwrapToolRecord(parsed2);
+    return record5 ? coerceTodoList(record5.todos ?? record5.items ?? record5.plan ?? record5.tasks ?? record5.entries) : null;
   } catch {
     return planFromChecklistText(trimmed)?.plan.map(({ step, status: status2 }) => ({ content: step, status: status2 })) ?? null;
   }
@@ -30065,10 +30685,12 @@ function decodeCreateRoute(request) {
     return null;
   const pluginRoute = decodeHarnessPluginRoute(request.params.model);
   if (pluginRoute) {
+    const { prewarm, ...selection } = pluginRoute;
     return {
       harnessId: pluginRoute.harnessId,
       routeMode: "native",
-      transportModelId: request.params.model,
+      transportModelId: prewarm ? encodeHarnessPluginRoute(selection) : request.params.model,
+      ...prewarm ? { prewarm } : {},
       ...pluginRoute.model ? { model: pluginRoute.model } : {},
       ...pluginRoute.thinkingOptionId ? { thinkingOptionId: pluginRoute.thinkingOptionId } : {},
       ...pluginRoute.permissionModeId ? { permissionModeId: pluginRoute.permissionModeId } : {}
@@ -30385,7 +31007,7 @@ import { open as open8, realpath as realpath4 } from "node:fs/promises";
 import path21 from "node:path";
 var MAX_METADATA_BYTES = 1024 * 1024;
 var REFERENCE_READ_TIMEOUT_MS = 2e3;
-var record3 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+var record4 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 async function nativeThreadSupportsReferences(input) {
   try {
     let timer;
@@ -30395,8 +31017,8 @@ async function nativeThreadSupportsReferences(input) {
         timer = setTimeout(() => resolve(null), REFERENCE_READ_TIMEOUT_MS);
       })
     ]).finally(() => clearTimeout(timer));
-    const result = record3(response) && record3(response.result) ? response.result : null;
-    const thread = result && record3(result.thread) ? result.thread : null;
+    const result = record4(response) && record4(response.result) ? response.result : null;
+    const thread = result && record4(result.thread) ? result.thread : null;
     if (thread?.id !== input.threadId || typeof thread.path !== "string") return false;
     const rollout = await realpath4(thread.path);
     let allowed = false;
@@ -30418,13 +31040,13 @@ async function nativeThreadSupportsReferences(input) {
       const newline2 = bytes.subarray(0, bytesRead).indexOf(10);
       if (newline2 < 0) return false;
       const line = JSON.parse(bytes.subarray(0, newline2).toString("utf8"));
-      if (!record3(line) || line.type !== "session_meta" || !record3(line.payload)) return false;
+      if (!record4(line) || line.type !== "session_meta" || !record4(line.payload)) return false;
       const metadata = line.payload;
       if (metadata.id !== input.threadId || !Array.isArray(metadata.dynamic_tools)) return false;
       return metadata.dynamic_tools.some((tool) => {
-        if (!record3(tool)) return false;
+        if (!record4(tool)) return false;
         if (tool.type === "namespace") {
-          return tool.name === "codex_app" && Array.isArray(tool.tools) && tool.tools.some((item) => record3(item) && item.name === "read_thread");
+          return tool.name === "codex_app" && Array.isArray(tool.tools) && tool.tools.some((item) => record4(item) && item.name === "read_thread");
         }
         return tool.name === "read_thread";
       });
@@ -30536,7 +31158,7 @@ var HarnessAccountInspectionCache = class {
 };
 
 // packages/host-runtime/src/app-server-host.ts
-import { createHash as createHash9, randomUUID as randomUUID16 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID17 } from "node:crypto";
 import os8 from "node:os";
 import path25 from "node:path";
 
@@ -30563,21 +31185,21 @@ function subagentMaterializer(store, parent, previousParent) {
   const legacyRecords = () => legacy ??= store.listThreads().then((records) => {
     const byRequest = /* @__PURE__ */ new Map();
     const children = /* @__PURE__ */ new Map();
-    for (const record4 of records) {
-      if (!record4.subagent || record4.harnessId !== parent.harnessId || !record4.nativeSessionRef)
+    for (const record5 of records) {
+      if (!record5.subagent || record5.harnessId !== parent.harnessId || !record5.nativeSessionRef)
         continue;
       const owner = {
-        hostThreadId: record4.subagent.parentHostThreadId,
-        harnessId: record4.harnessId
+        hostThreadId: record5.subagent.parentHostThreadId,
+        harnessId: record5.harnessId
       };
       const key = childCreateRequest(
         owner,
-        record4.nativeSessionRef,
-        record4.subagent.nativeSubagentId
+        record5.nativeSessionRef,
+        record5.subagent.nativeSubagentId
       );
-      if (!byRequest.has(key) || record4.state === "ready") byRequest.set(key, record4);
+      if (!byRequest.has(key) || record5.state === "ready") byRequest.set(key, record5);
       const siblings = children.get(owner.hostThreadId) ?? [];
-      siblings.push(record4);
+      siblings.push(record5);
       children.set(owner.hostThreadId, siblings);
     }
     return { byRequest, children };
@@ -30647,11 +31269,11 @@ function subagentMaterializer(store, parent, previousParent) {
 async function materializeExternalSubagent(store, parent, child) {
   return subagentMaterializer(store, parent)(child);
 }
-async function projectExternalSnapshot(store, record4, snapshot2, previousParent) {
-  const materialize = subagentMaterializer(store, record4, previousParent);
+async function projectExternalSnapshot(store, record5, snapshot2, previousParent) {
+  const materialize = subagentMaterializer(store, record5, previousParent);
   const turns = [];
   for (const [index, turn] of snapshot2.turns.entries()) {
-    const mapping = record4.turnMappings[index];
+    const mapping = record5.turnMappings[index];
     if (!mapping) throw new Error("External Snapshot mapping is incomplete");
     const items = await Promise.all(
       turn.items.map(async (entry) => {
@@ -30667,9 +31289,9 @@ async function projectExternalSnapshot(store, record4, snapshot2, previousParent
     );
     turns.push(
       projectHistoricalTurn({
-        threadId: record4.hostThreadId,
+        threadId: record5.hostThreadId,
         turnId: mapping.hostTurnId,
-        cwd: record4.cwd,
+        cwd: record5.cwd,
         snapshot: { ...turn, items }
       })
     );
@@ -30776,11 +31398,11 @@ var ExternalThreadRepository = class {
   removeThread(hostThreadId) {
     return this.store.removeThread(hostThreadId);
   }
-  async persistTurn(record4, hostTurnId, nativeTurnRef, nativeCheckpointRef) {
-    if (record4.state !== "ready" || !record4.nativeSessionRef || nativeTurnRef.harnessId !== record4.harnessId || nativeTurnRef.nativeSessionId !== record4.nativeSessionRef.nativeSessionId || nativeCheckpointRef && (nativeCheckpointRef.harnessId !== record4.harnessId || nativeCheckpointRef.nativeSessionId !== record4.nativeSessionRef.nativeSessionId)) {
+  async persistTurn(record5, hostTurnId, nativeTurnRef, nativeCheckpointRef) {
+    if (record5.state !== "ready" || !record5.nativeSessionRef || nativeTurnRef.harnessId !== record5.harnessId || nativeTurnRef.nativeSessionId !== record5.nativeSessionRef.nativeSessionId || nativeCheckpointRef && (nativeCheckpointRef.harnessId !== record5.harnessId || nativeCheckpointRef.nativeSessionId !== record5.nativeSessionRef.nativeSessionId)) {
       throw new Error("Live Turn identity does not belong to the stored Thread");
     }
-    return this.store.upsertTurnMappings(record4.hostThreadId, [
+    return this.store.upsertTurnMappings(record5.hostThreadId, [
       {
         hostTurnId,
         nativeTurnRef,
@@ -30788,12 +31410,12 @@ var ExternalThreadRepository = class {
       }
     ]);
   }
-  async commitDerivedSnapshot(record4, nativeSessionRef, snapshot2) {
-    if (record4.state !== "creating" || record4.turnMappings.length !== 0) {
+  async commitDerivedSnapshot(record5, nativeSessionRef, snapshot2) {
+    if (record5.state !== "creating" || record5.turnMappings.length !== 0) {
       throw new Error("Derived Thread must be provisional before Snapshot commit");
     }
     const mappings = snapshot2.turns.map((turn) => {
-      if (turn.nativeTurnRef.harnessId !== record4.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record4.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
+      if (turn.nativeTurnRef.harnessId !== record5.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record5.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
         throw new Error("Derived Snapshot identity does not belong to its Native Session");
       }
       return {
@@ -30803,7 +31425,7 @@ var ExternalThreadRepository = class {
       };
     });
     const nextRecord = await this.store.commitReady({
-      hostThreadId: record4.hostThreadId,
+      hostThreadId: record5.hostThreadId,
       nativeSessionRef,
       turnMappings: mappings
     });
@@ -30884,8 +31506,8 @@ var ExternalThreadRepository = class {
       turns: await projectExternalSnapshot(this.store, nextRecord, snapshot2, current)
     };
   }
-  async sessionTreeId(record4) {
-    let current = record4;
+  async sessionTreeId(record5) {
+    let current = record5;
     const visited = /* @__PURE__ */ new Set();
     while (current.subagent || current.forkSource) {
       if (visited.has(current.hostThreadId))
@@ -30899,21 +31521,21 @@ var ExternalThreadRepository = class {
     }
     return current.hostThreadId;
   }
-  async alignSnapshot(record4, snapshot2) {
-    const nativeSessionRef = record4.nativeSessionRef;
-    if (record4.state === "creating" && !nativeSessionRef && snapshot2.turns.length === 0) {
-      return { record: record4, turns: [] };
+  async alignSnapshot(record5, snapshot2) {
+    const nativeSessionRef = record5.nativeSessionRef;
+    if (record5.state === "creating" && !nativeSessionRef && snapshot2.turns.length === 0) {
+      return { record: record5, turns: [] };
     }
-    if (!nativeSessionRef || record4.state !== "ready") {
+    if (!nativeSessionRef || record5.state !== "ready") {
       throw new Error("External Thread has no committed Native Session identity");
     }
     for (const turn of snapshot2.turns) {
-      if (turn.nativeTurnRef.harnessId !== record4.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record4.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
+      if (turn.nativeTurnRef.harnessId !== record5.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record5.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
         throw new Error("External Snapshot identity does not belong to the stored Thread");
       }
     }
     const mappingsByNative = new Map(
-      record4.turnMappings.map(
+      record5.turnMappings.map(
         (mapping) => [nativeTurnKey2(mapping.nativeTurnRef), mapping]
       )
     );
@@ -30934,11 +31556,11 @@ var ExternalThreadRepository = class {
       };
     });
     const orderedMappings = aligned.map(({ mapping }) => mapping);
-    const mappingsChanged = orderedMappings.length !== record4.turnMappings.length || orderedMappings.some((mapping, index) => {
-      const persisted = record4.turnMappings[index];
+    const mappingsChanged = orderedMappings.length !== record5.turnMappings.length || orderedMappings.some((mapping, index) => {
+      const persisted = record5.turnMappings[index];
       return !persisted || !sameMapping(mapping, persisted);
     });
-    const nextRecord = mappingsChanged ? await this.store.reconcileTurnMappings(record4.hostThreadId, orderedMappings) : record4;
+    const nextRecord = mappingsChanged ? await this.store.reconcileTurnMappings(record5.hostThreadId, orderedMappings) : record5;
     return {
       record: nextRecord,
       turns: await projectExternalSnapshot(this.store, nextRecord, snapshot2)
@@ -30966,9 +31588,9 @@ function threadSectionFields(placement) {
   } : { section: null, sectionEnteredAt: null };
 }
 function externalThreadValue(input) {
-  const { record: record4 } = input;
-  const createdAt = Math.floor(Date.parse(record4.createdAt) / 1e3);
-  const updatedAt = Math.floor(Date.parse(record4.updatedAt) / 1e3);
+  const { record: record5 } = input;
+  const createdAt = Math.floor(Date.parse(record5.createdAt) / 1e3);
+  const updatedAt = Math.floor(Date.parse(record5.updatedAt) / 1e3);
   const preview = input.turns.flatMap((turn) => Array.isArray(turn.items) ? turn.items : []).find(
     (item) => typeof item === "object" && item !== null && !Array.isArray(item) && item.type === "userMessage"
   );
@@ -30977,22 +31599,22 @@ function externalThreadValue(input) {
     (part) => typeof part === "object" && part !== null && !Array.isArray(part) && part.type === "text"
   ).map((part) => typeof part.text === "string" ? part.text : "").join("\n") : "";
   return {
-    id: record4.hostThreadId,
+    id: record5.hostThreadId,
     sessionId: input.sessionId,
     path: null,
-    cwd: record4.cwd,
-    source: record4.subagent ? {
+    cwd: record5.cwd,
+    source: record5.subagent ? {
       subAgent: {
         thread_spawn: {
-          parent_thread_id: record4.subagent.parentHostThreadId,
+          parent_thread_id: record5.subagent.parentHostThreadId,
           depth: 1,
           agent_path: null,
-          agent_nickname: record4.title || null,
-          agent_role: record4.subagent.role ?? null
+          agent_nickname: record5.title || null,
+          agent_role: record5.subagent.role ?? null
         }
       }
     } : "vscode",
-    threadSource: record4.subagent ? "subAgentThreadSpawn" : null,
+    threadSource: record5.subagent ? "subAgentThreadSpawn" : null,
     modelProvider: "codexhost",
     cliVersion: "codexhost",
     createdAt,
@@ -31001,23 +31623,23 @@ function externalThreadValue(input) {
     status: input.loaded === false ? { type: "notLoaded" } : input.running ? { type: "active", activeFlags: [] } : { type: "idle" },
     turns: input.turns,
     preview: previewText,
-    name: record4.title || null,
-    gitInfo: record4.gitInfo ? {
-      branch: record4.gitInfo.branch ?? null,
-      originUrl: record4.gitInfo.originUrl ?? null,
-      sha: record4.gitInfo.sha ?? null
+    name: record5.title || null,
+    gitInfo: record5.gitInfo ? {
+      branch: record5.gitInfo.branch ?? null,
+      originUrl: record5.gitInfo.originUrl ?? null,
+      sha: record5.gitInfo.sha ?? null
     } : null,
-    forkedFromId: record4.forkSource?.hostThreadId ?? null,
-    parentThreadId: record4.subagent?.parentHostThreadId ?? null,
-    ephemeral: record4.ephemeral,
-    canAcceptDirectInput: record4.subagent ? false : input.loaded === false ? null : true,
-    historyMode: record4.historyMode,
+    forkedFromId: record5.forkSource?.hostThreadId ?? null,
+    parentThreadId: record5.subagent?.parentHostThreadId ?? null,
+    ephemeral: record5.ephemeral,
+    canAcceptDirectInput: record5.subagent ? false : input.loaded === false ? null : true,
+    historyMode: record5.historyMode,
     isPinned: false,
-    projectId: record4.projectId ?? null,
-    daybreakEnabled: record4.daybreakEnabled ?? null,
+    projectId: record5.projectId ?? null,
+    daybreakEnabled: record5.daybreakEnabled ?? null,
     ...threadSectionFields(input.placement),
-    agentNickname: record4.subagent ? record4.title || null : null,
-    agentRole: record4.subagent?.role ?? null,
+    agentNickname: record5.subagent ? record5.title || null : null,
+    agentRole: record5.subagent?.role ?? null,
     extra: null
   };
 }
@@ -31256,14 +31878,14 @@ async function settleExternalOutputFailure(thread, error51, project2, diagnose)
 function fixedError(code, message2) {
   return { code, message: message2 };
 }
-function importedThread(record4) {
+function importedThread(record5) {
   return {
     ok: true,
-    threadId: record4.hostThreadId,
+    threadId: record5.hostThreadId,
     thread: externalThreadValue({
-      record: record4,
+      record: record5,
       turns: [],
-      sessionId: record4.hostThreadId,
+      sessionId: record5.hostThreadId,
       loaded: false
     })
   };
@@ -31284,7 +31906,7 @@ var HarnessSessionImporter = class {
   }
   #mappedRecord(records, nativeSessionId) {
     return records.find(
-      (record4) => !record4.subagent && record4.state === "ready" && record4.nativeSessionRef?.harnessId === this.#harnessId && record4.nativeSessionRef.nativeSessionId === nativeSessionId
+      (record5) => !record5.subagent && record5.state === "ready" && record5.nativeSessionRef?.harnessId === this.#harnessId && record5.nativeSessionRef.nativeSessionId === nativeSessionId
     );
   }
   #unavailable() {
@@ -31303,7 +31925,7 @@ var HarnessSessionImporter = class {
       }
       const mapped = new Set(
         (await this.#repository.list()).flatMap(
-          (record4) => !record4.subagent && record4.state === "ready" && record4.nativeSessionRef?.harnessId === this.#harnessId ? [record4.nativeSessionRef.nativeSessionId] : []
+          (record5) => !record5.subagent && record5.state === "ready" && record5.nativeSessionRef?.harnessId === this.#harnessId ? [record5.nativeSessionRef.nativeSessionId] : []
         )
       );
       const superseded = this.#repository.supersededNativeSessionIds(this.#harnessId);
@@ -31395,8 +32017,8 @@ var HarnessSessionImporter = class {
       return { ok: false, error: fixedError(-32081, "Session import could not be persisted") };
     }
     try {
-      const record4 = await this.#repository.commitNative(provisional.hostThreadId, ref.data, []);
-      return importedThread(record4);
+      const record5 = await this.#repository.commitNative(provisional.hostThreadId, ref.data, []);
+      return importedThread(record5);
     } catch (error51) {
       await this.#repository.removeProvisional(provisional.hostThreadId).catch((cleanupError) => this.#diagnose(cleanupError));
       if (error51 instanceof MappingStoreError && error51.code === "DUPLICATE_NATIVE_SESSION") {
@@ -32693,6 +33315,19 @@ var ExternalThreadRuntime = class {
     this.#threads.delete(threadId2);
     this.#steeredTurnIds.delete(threadId2);
   }
+  /** Confirm release before forgetting either the Session owner or its persisted mapping. */
+  async deleteThread(hostThreadId) {
+    await this.#withLifecycle(hostThreadId, async () => {
+      const thread = this.#threads.get(hostThreadId);
+      if (thread) {
+        thread.sessionUnavailable = true;
+        thread.stateObserver.fault(new Error("External Thread is being deleted"));
+        await this.#lifecycle.release(hostThreadId, thread.session, thread.outputTask);
+      }
+      this.remove(hostThreadId);
+      await this.#repository.removeThread(hostThreadId);
+    });
+  }
   clear() {
     this.#threads.clear();
     this.#steeredTurnIds.clear();
@@ -32821,9 +33456,9 @@ var ExternalThreadRuntime = class {
   async #retireSubagents(parent, bestEffort = false) {
     const parentId = parent.id;
     const ancestors = /* @__PURE__ */ new Map();
-    const descendant = async (record4) => {
+    const descendant = async (record5) => {
       const visited = /* @__PURE__ */ new Set();
-      let ownerId = record4?.subagent?.parentHostThreadId;
+      let ownerId = record5?.subagent?.parentHostThreadId;
       while (ownerId && !visited.has(ownerId)) {
         if (ownerId === parentId) return true;
         visited.add(ownerId);
@@ -32871,23 +33506,23 @@ var ExternalThreadRuntime = class {
       if (failure) return { kind: "error", error: { code: -32075, message: failure } };
       return { kind: "external", record: loaded.record, thread: loaded };
     }
-    let record4;
+    let record5;
     try {
-      record4 = await this.#repository.find(threadId2);
+      record5 = await this.#repository.find(threadId2);
     } catch {
       return {
         kind: "error",
         error: { code: -32081, message: "External Thread ownership could not be read" }
       };
     }
-    if (!record4) return { kind: "official" };
-    if (record4.state !== "ready" || !record4.nativeSessionRef) {
+    if (!record5) return { kind: "official" };
+    if (record5.state !== "ready" || !record5.nativeSessionRef) {
       return {
         kind: "error",
         error: { code: -32079, message: "External Native Session is unavailable" }
       };
     }
-    return { kind: "external", record: record4, thread: null };
+    return { kind: "external", record: record5, thread: null };
   }
   async resolve(threadId2) {
     try {
@@ -33098,16 +33733,16 @@ var ExternalThreadRuntime = class {
       return failure;
     }
   }
-  async #restore(record4) {
-    const harnessId = record4.harnessId;
+  async #restore(record5) {
+    const harnessId = record5.harnessId;
     const adapter = this.#adapters.get(harnessId);
-    if (!adapter || !record4.nativeSessionRef) {
+    if (!adapter || !record5.nativeSessionRef) {
       throw new ExternalThreadOpenError({
         code: -32077,
         message: "External Harness is unavailable"
       });
     }
-    if (record4.subagent) {
+    if (record5.subagent) {
       const subagents = adapter.subagents;
       if (!subagents) {
         throw new ExternalThreadOpenError({
@@ -33115,14 +33750,14 @@ var ExternalThreadRuntime = class {
           message: "External Harness Subagent history is unavailable"
         });
       }
-      const subagent = record4.subagent;
-      const parent = record4.nativeSessionRef;
+      const subagent = record5.subagent;
+      const parent = record5.nativeSessionRef;
       const snapshot2 = await subagents.readSnapshot({
         parent,
         nativeSubagentId: subagent.nativeSubagentId,
-        cwd: record4.cwd
+        cwd: record5.cwd
       });
-      const latest = await this.#repository.find(record4.hostThreadId);
+      const latest = await this.#repository.find(record5.hostThreadId);
       if (latest?.state === "ready" && latest.nativeSessionRef && JSON.stringify(latest.nativeSessionRef) !== JSON.stringify(parent)) {
         return this.#restore(latest);
       }
@@ -33130,16 +33765,16 @@ var ExternalThreadRuntime = class {
         throw new ExternalThreadOpenError(mapExternalThreadHarnessError(snapshot2.error, "read"));
       }
       const session2 = new ReadonlySnapshotSession(
-        record4.harnessId,
-        record4.nativeSessionRef,
+        record5.harnessId,
+        record5.nativeSessionRef,
         snapshot2.value,
         () => subagents.readSnapshot({
           parent,
           nativeSubagentId: subagent.nativeSubagentId,
-          cwd: record4.cwd
+          cwd: record5.cwd
         })
       );
-      const aligned = await this.#repository.alignSnapshot(record4, snapshot2.value);
+      const aligned = await this.#repository.alignSnapshot(record5, snapshot2.value);
       const sessionId = await this.#repository.sessionTreeId(aligned.record);
       return this.register({
         record: aligned.record,
@@ -33150,13 +33785,13 @@ var ExternalThreadRuntime = class {
         ...snapshot2.value.state ? { restoredState: snapshot2.value.state } : {}
       });
     }
-    const restoredSelection = decodeExternalTransportSelection(harnessId, record4.transportModelId);
+    const restoredSelection = decodeExternalTransportSelection(harnessId, record5.transportModelId);
     const opened = await adapter.open({
       kind: "resume",
-      cwd: record4.cwd,
-      environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: record4.hostThreadId },
-      nativeRef: record4.nativeSessionRef,
-      knownTurnRefs: record4.turnMappings.map(({ nativeTurnRef }) => nativeTurnRef),
+      cwd: record5.cwd,
+      environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: record5.hostThreadId },
+      nativeRef: record5.nativeSessionRef,
+      knownTurnRefs: record5.turnMappings.map(({ nativeTurnRef }) => nativeTurnRef),
       ...restoredSelection?.model ? { model: restoredSelection.model } : {},
       ...restoredSelection?.thinkingOptionId ? { thinkingOptionId: restoredSelection.thinkingOptionId } : {},
       ...restoredSelection?.permissionModeId ? { permissionModeId: restoredSelection.permissionModeId } : {}
@@ -33170,7 +33805,7 @@ var ExternalThreadRuntime = class {
       if (!snapshot2.ok) {
         throw new ExternalThreadOpenError(mapExternalThreadHarnessError(snapshot2.error, "read"));
       }
-      let aligned = await this.#repository.alignSnapshot(record4, snapshot2.value);
+      let aligned = await this.#repository.alignSnapshot(record5, snapshot2.value);
       const restoredState = snapshot2.value.state;
       const effectiveModel = restoredState ? restoredState.effectiveModel : restoredSelection?.model;
       const effectiveThinkingOptionId = restoredState ? restoredState.effectiveThinkingOptionId : restoredSelection?.thinkingOptionId;
@@ -33216,14 +33851,136 @@ var ExternalThreadRuntime = class {
       });
     } catch (error51) {
       if (error51 instanceof ExternalSessionReleaseError) throw error51;
-      await this.#lifecycle.release(record4.hostThreadId, session, Promise.resolve());
+      await this.#lifecycle.release(record5.hostThreadId, session, Promise.resolve());
       throw error51;
     }
   }
 };
 
-// packages/host-runtime/src/external-turn-steering.ts
+// packages/host-runtime/src/external-thread-queue.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
+var ExternalQueueError = class extends Error {
+  constructor(code, message2) {
+    super(message2);
+    this.code = code;
+  }
+  code;
+};
+var publicSubmission = ({
+  id: id2,
+  input,
+  clientUserMessageId
+}) => ({
+  id: id2,
+  input,
+  clientUserMessageId
+});
+var DEFAULT_PAGE_SIZE3 = 50;
+var ExternalThreadQueue = class {
+  #queues = /* @__PURE__ */ new Map();
+  #notifyChanged;
+  #createId;
+  constructor(options2) {
+    this.#notifyChanged = options2.notifyChanged;
+    this.#createId = options2.createId ?? randomUUID12;
+  }
+  has(threadId2) {
+    return (this.#queues.get(threadId2)?.length ?? 0) > 0;
+  }
+  list(threadId2, params) {
+    const items = this.#queues.get(threadId2) ?? [];
+    const start = params.cursor == null ? 0 : Number(params.cursor);
+    if (!Number.isSafeInteger(start) || start < 0 || start > items.length) {
+      throw new ExternalQueueError(-32602, "Invalid thread/queue/list cursor");
+    }
+    const limit = typeof params.limit === "number" && Number.isSafeInteger(params.limit) && params.limit > 0 ? params.limit : DEFAULT_PAGE_SIZE3;
+    const end = Math.min(items.length, start + limit);
+    return {
+      data: items.slice(start, end).map((item) => publicSubmission(item)),
+      nextCursor: end < items.length ? String(end) : null
+    };
+  }
+  async add(threadId2, input, clientUserMessageId, sourceHostId) {
+    const submission = { id: this.#createId(), input, clientUserMessageId, sourceHostId };
+    this.#items(threadId2).push(submission);
+    await this.#notifyChanged(threadId2);
+    return publicSubmission(submission);
+  }
+  async update(threadId2, id2, input) {
+    const items = this.#queues.get(threadId2) ?? [];
+    const index = items.findIndex((item) => item.id === id2);
+    const current = items[index];
+    if (!current) throw new ExternalQueueError(-32602, "Queued submission was not found");
+    const submission = { ...current, input };
+    items[index] = submission;
+    await this.#notifyChanged(threadId2);
+    return publicSubmission(submission);
+  }
+  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;
+    items.splice(index, 1);
+    this.#prune(threadId2);
+    await this.#notifyChanged(threadId2);
+    return true;
+  }
+  /** Listed IDs move to the front in the given order; unlisted entries keep their order. */
+  async reorder(threadId2, ids) {
+    const items = this.#queues.get(threadId2);
+    if (!items) return;
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const ordered = ids.flatMap((id2) => {
+      const item = byId.get(id2);
+      byId.delete(id2);
+      return item ? [item] : [];
+    });
+    items.splice(0, items.length, ...ordered, ...byId.values());
+    await this.#notifyChanged(threadId2);
+  }
+  /** Removes the submission a Turn is about to start; `restore` returns it if the start fails. */
+  take(threadId2, id2) {
+    const items = this.#queues.get(threadId2) ?? [];
+    const index = id2 == null ? 0 : items.findIndex((item) => item.id === id2);
+    const submission = index === -1 ? void 0 : items[index];
+    if (!submission) throw new ExternalQueueError(-32602, "Queued submission was not found");
+    items.splice(index, 1);
+    this.#prune(threadId2);
+    return {
+      submission: publicSubmission(submission),
+      sourceHostId: submission.sourceHostId,
+      index
+    };
+  }
+  restore(threadId2, taken) {
+    const items = this.#items(threadId2);
+    if (items.some((item) => item.id === taken.submission.id)) return;
+    items.splice(Math.min(taken.index, items.length), 0, {
+      ...taken.submission,
+      sourceHostId: taken.sourceHostId
+    });
+  }
+  notifyChanged(threadId2) {
+    return this.#notifyChanged(threadId2);
+  }
+  forget(threadId2) {
+    this.#queues.delete(threadId2);
+  }
+  #items(threadId2) {
+    let items = this.#queues.get(threadId2);
+    if (!items) {
+      items = [];
+      this.#queues.set(threadId2, items);
+    }
+    return items;
+  }
+  #prune(threadId2) {
+    if (this.#queues.get(threadId2)?.length === 0) this.#queues.delete(threadId2);
+  }
+};
+
+// packages/host-runtime/src/external-turn-steering.ts
+import { randomUUID as randomUUID13 } from "node:crypto";
 
 // packages/host-runtime/src/external-command-routing.ts
 var ExternalCommandError = class extends Error {
@@ -33344,7 +34101,7 @@ async function insertNativeSteer(thread, input, host) {
     thread.steeredTurnIds.add(input.turnId);
     const item = {
       type: "userMessage",
-      itemId: hostItemIdSchema.parse(randomUUID12()),
+      itemId: hostItemIdSchema.parse(randomUUID13()),
       input: displayed
     };
     try {
@@ -33576,7 +34333,7 @@ function sameWorkspace(left, right) {
 }
 
 // packages/host-runtime/src/harness-delegation-coordinator.ts
-import { createHash as createHash8, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID14 } from "node:crypto";
 import path24 from "node:path";
 
 // packages/host-runtime/src/delegation-snapshot.ts
@@ -33880,11 +34637,11 @@ var HarnessDelegationCoordinator = class {
       });
       this.#validateConfiguration(inspected.inspection, input.model, input.thinkingOptionId);
     }
-    const delegationId = hostThreadIdSchema.parse(randomUUID13());
-    const childThreadId = hostThreadIdSchema.parse(randomUUID13());
-    const turnId = hostTurnIdSchema.parse(randomUUID13());
-    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID13();
-    let record4 = await this.#repository.createProvisional(
+    const delegationId = hostThreadIdSchema.parse(randomUUID14());
+    const childThreadId = hostThreadIdSchema.parse(randomUUID14());
+    const turnId = hostTurnIdSchema.parse(randomUUID14());
+    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID14();
+    let record5 = await this.#repository.createProvisional(
       createExternalThreadRecordInput({
         hostThreadId: childThreadId,
         createRequestId,
@@ -33915,7 +34672,7 @@ var HarnessDelegationCoordinator = class {
         });
         const opened = await adapter.open({
           kind: "create",
-          cwd: record4.cwd,
+          cwd: record5.cwd,
           environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: childThreadId },
           executionPolicy: "unattended-full-access",
           ...input.model ? { model: input.model } : {},
@@ -33924,21 +34681,21 @@ var HarnessDelegationCoordinator = class {
         if (!opened.ok) throw new DelegationControlError("DELEGATION_FAILED", opened.error.message);
         session = opened.value;
         if (session.initialState.nativeRef) {
-          record4 = await this.#repository.commitNative(
-            record4.hostThreadId,
+          record5 = await this.#repository.commitNative(
+            record5.hostThreadId,
             session.initialState.nativeRef
           );
         }
         const threadValue = externalThreadValue({
-          record: record4,
+          record: record5,
           turns: [],
-          sessionId: record4.hostThreadId,
+          sessionId: record5.hostThreadId,
           running: true
         });
         const thread = this.#registerExternalThread({
-          record: record4,
+          record: record5,
           session,
-          sessionId: record4.hostThreadId,
+          sessionId: record5.hostThreadId,
           thread: threadValue,
           turns: [],
           ...input.model ? { requestedModel: input.model } : {},
@@ -33995,7 +34752,7 @@ var HarnessDelegationCoordinator = class {
               } : {}
             }
           }),
-          cwd: record4.cwd,
+          cwd: record5.cwd,
           parentThreadId
         };
       } catch (error51) {
@@ -34037,7 +34794,7 @@ var HarnessDelegationCoordinator = class {
     if (this.#externalThreadBusy(thread) || thread.activeTurnId) {
       throw new DelegationControlError("THREAD_BUSY", "Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID13());
+    const turnId = hostTurnIdSchema.parse(randomUUID14());
     try {
       await this.#startExternalTurn(thread, input.message, turnId);
     } catch (error51) {
@@ -34144,19 +34901,19 @@ var HarnessDelegationCoordinator = class {
     const parent = hostThreadIdSchema.parse(input.parentThreadId);
     const delegations = await this.#repository.listDelegations(parent);
     const records = await this.#repository.list();
-    const byId = new Map(records.map((record4) => [record4.hostThreadId, record4]));
+    const byId = new Map(records.map((record5) => [record5.hostThreadId, record5]));
     const rows = delegations.map((delegation) => {
-      const record4 = byId.get(delegation.childHostThreadId);
+      const record5 = byId.get(delegation.childHostThreadId);
       return {
         threadId: delegation.childHostThreadId,
         harnessId: delegation.targetHarnessId,
         deepLink: `codex://threads/${delegation.childHostThreadId}`,
         status: delegation.status,
-        ...record4 ? {
-          cwd: record4.cwd,
-          title: record4.title,
-          createdAt: record4.createdAt,
-          updatedAt: record4.updatedAt
+        ...record5 ? {
+          cwd: record5.cwd,
+          title: record5.title,
+          createdAt: record5.createdAt,
+          updatedAt: record5.updatedAt
         } : {
           createdAt: delegation.createdAt,
           updatedAt: delegation.updatedAt
@@ -34250,19 +35007,19 @@ var HarnessDelegationCoordinator = class {
     }
   }
   async #parentMetadata(parentThreadId) {
-    const record4 = await this.#repository.find(parentThreadId);
-    if (record4)
+    const record5 = await this.#repository.find(parentThreadId);
+    if (record5)
       return {
-        harnessId: record4.harnessId,
-        cwd: record4.cwd,
-        title: record4.title
+        harnessId: record5.harnessId,
+        cwd: record5.cwd,
+        title: record5.title
       };
     const metadata = await this.#officialThreadMetadata(parentThreadId).catch(() => ({}));
     return { harnessId: "codex", ...metadata };
   }
   async #existingResult(delegation) {
-    const record4 = await this.#repository.find(delegation.childHostThreadId);
-    const turnId = record4?.turnMappings.at(-1)?.hostTurnId ?? "pending";
+    const record5 = await this.#repository.find(delegation.childHostThreadId);
+    const turnId = record5?.turnMappings.at(-1)?.hostTurnId ?? "pending";
     return {
       ...this.#result(
         delegation.delegationId,
@@ -34271,7 +35028,7 @@ var HarnessDelegationCoordinator = class {
         delegation.targetHarnessId,
         delegation.status
       ),
-      ...record4 ? { cwd: record4.cwd } : {},
+      ...record5 ? { cwd: record5.cwd } : {},
       parentThreadId: delegation.parentHostThreadId
     };
   }
@@ -36687,10 +37444,10 @@ var SingleNativeCodexAccount = class {
 };
 
 // packages/host-runtime/src/codex-runtime/official-runtime-owner.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 
 // packages/host-runtime/src/official-request-broker.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
 function isRecord15(value2) {
@@ -36706,7 +37463,7 @@ var OfficialRequestBroker = class {
   constructor(input) {
     this.#send = input.send;
     this.#timeoutMs = input.timeoutMs ?? 3e4;
-    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID14()}`);
+    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID15()}`);
   }
   get pendingCount() {
     return this.#pending.size;
@@ -37060,7 +37817,7 @@ var OfficialRuntimeOwner = class {
   }
   #attach(role, output, onBackendStopped) {
     const client = {
-      id: randomUUID15(),
+      id: randomUUID16(),
       role,
       output,
       ...onBackendStopped ? { onBackendStopped } : {},
@@ -37218,7 +37975,7 @@ var OfficialRuntimeOwner = class {
     if (!object4(value2)) return client.output(event);
     if (typeof value2.id === "string" || typeof value2.id === "number") {
       if (typeof value2.method === "string") {
-        const id2 = `codexhost:server:${client.id}:${event.generation}:${randomUUID15()}`;
+        const id2 = `codexhost:server:${client.id}:${event.generation}:${randomUUID16()}`;
         client.serverRequests.set(id2, value2.id);
         const projected = { ...value2, id: id2 };
         return client.output({
@@ -37606,9 +38363,9 @@ function externalAnchor(entry) {
   if (entry.source !== "external") throw new Error("Expected an External Thread list entry");
   return { timestamp: entry.timestamp, threadId: threadId(entry.thread) };
 }
-function includesExternalRecord(record4, query, byId, sectionId) {
-  if (record4.state !== "ready" || !record4.nativeSessionRef) return false;
-  let current = record4;
+function includesExternalRecord(record5, query, byId, sectionId) {
+  if (record5.state !== "ready" || !record5.nativeSessionRef) return false;
+  let current = record5;
   const owners = /* @__PURE__ */ new Set();
   while (current.subagent) {
     if (owners.has(current.hostThreadId)) return false;
@@ -37618,32 +38375,32 @@ function includesExternalRecord(record4, query, byId, sectionId) {
       return false;
     current = parent;
   }
-  const sourceKind = record4.subagent ? "subAgentThreadSpawn" : "vscode";
+  const sourceKind = record5.subagent ? "subAgentThreadSpawn" : "vscode";
   const scoped = query.parentThreadId !== null || query.ancestorThreadId !== null;
-  if (record4.subagent && !scoped && !query.sourceKinds?.some((kind) => kind === "subAgent" || kind === "subAgentThreadSpawn"))
+  if (record5.subagent && !scoped && !query.sourceKinds?.some((kind) => kind === "subAgent" || kind === "subAgentThreadSpawn"))
     return false;
-  if (query.parentThreadId !== null && record4.subagent?.parentHostThreadId !== query.parentThreadId)
+  if (query.parentThreadId !== null && record5.subagent?.parentHostThreadId !== query.parentThreadId)
     return false;
   if (query.ancestorThreadId !== null) {
-    let parentId = record4.subagent?.parentHostThreadId;
-    const visited = /* @__PURE__ */ new Set([record4.hostThreadId]);
+    let parentId = record5.subagent?.parentHostThreadId;
+    const visited = /* @__PURE__ */ new Set([record5.hostThreadId]);
     while (parentId && parentId !== query.ancestorThreadId && !visited.has(parentId)) {
       visited.add(parentId);
       parentId = byId.get(parentId)?.subagent?.parentHostThreadId;
     }
-    if (record4.hostThreadId === query.ancestorThreadId || parentId !== query.ancestorThreadId)
+    if (record5.hostThreadId === query.ancestorThreadId || parentId !== query.ancestorThreadId)
       return false;
   }
-  if (record4.archived !== query.archived) return false;
-  if (query.projectId !== void 0 && (record4.projectId ?? null) !== query.projectId) return false;
-  if (query.cwd !== null && !query.cwd.includes(record4.cwd)) return false;
+  if (record5.archived !== query.archived) return false;
+  if (query.projectId !== void 0 && (record5.projectId ?? null) !== query.projectId) return false;
+  if (query.cwd !== null && !query.cwd.includes(record5.cwd)) return false;
   if (query.modelProviders !== null && query.modelProviders.length > 0 && !query.modelProviders.includes("codexhost")) {
     return false;
   }
-  if (query.sourceKinds !== null && query.sourceKinds.length > 0 && !query.sourceKinds.includes(sourceKind) && !(record4.subagent && query.sourceKinds.includes("subAgent"))) {
+  if (query.sourceKinds !== null && query.sourceKinds.length > 0 && !query.sourceKinds.includes(sourceKind) && !(record5.subagent && query.sourceKinds.includes("subAgent"))) {
     return false;
   }
-  if (query.searchTerm !== null && !record4.title.toLowerCase().includes(query.searchTerm.toLowerCase())) {
+  if (query.searchTerm !== null && !record5.title.toLowerCase().includes(query.searchTerm.toLowerCase())) {
     return false;
   }
   if (query.isPinned === true) return false;
@@ -37651,7 +38408,7 @@ function includesExternalRecord(record4, query, byId, sectionId) {
   return true;
 }
 function resolveExternalSessionTreeIds(records) {
-  const byId = new Map(records.map((record4) => [record4.hostThreadId, record4]));
+  const byId = new Map(records.map((record5) => [record5.hostThreadId, record5]));
   const resolved = /* @__PURE__ */ new Map();
   const resolve = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
@@ -37662,7 +38419,7 @@ function resolveExternalSessionTreeIds(records) {
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record4 of path43) resolved.set(record4.hostThreadId, known);
+        for (const record5 of path43) resolved.set(record5.hostThreadId, known);
         return known;
       }
       if (visited.has(current.hostThreadId)) {
@@ -37674,32 +38431,32 @@ function resolveExternalSessionTreeIds(records) {
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record4 of path43) resolved.set(record4.hostThreadId, root);
+        for (const record5 of path43) resolved.set(record5.hostThreadId, root);
         return root;
       }
       current = source;
     }
   };
-  for (const record4 of records) resolve(record4);
+  for (const record5 of records) resolve(record5);
   return resolved;
 }
 function externalThreadListEntries(input) {
   const sessionIds = resolveExternalSessionTreeIds(input.records);
-  const byId = new Map(input.records.map((record4) => [record4.hostThreadId, record4]));
+  const byId = new Map(input.records.map((record5) => [record5.hostThreadId, record5]));
   return input.records.filter(
-    (record4) => includesExternalRecord(
-      record4,
+    (record5) => includesExternalRecord(
+      record5,
       input.query,
       byId,
-      input.placementOf?.(record4.hostThreadId)?.section.id ?? null
+      input.placementOf?.(record5.hostThreadId)?.section.id ?? null
     )
-  ).map((record4) => {
-    const runtime = input.runtimeFor(record4.hostThreadId);
-    const sessionId = sessionIds.get(record4.hostThreadId);
+  ).map((record5) => {
+    const runtime = input.runtimeFor(record5.hostThreadId);
+    const sessionId = sessionIds.get(record5.hostThreadId);
     if (!sessionId) throw new Error("External Thread Session tree could not be resolved");
-    const placement = input.placementOf?.(record4.hostThreadId);
+    const placement = input.placementOf?.(record5.hostThreadId);
     const thread = externalThreadValue({
-      record: record4,
+      record: record5,
       turns: [],
       sessionId,
       ...runtime ? { running: runtime.running } : { loaded: false },
@@ -37708,7 +38465,7 @@ function externalThreadListEntries(input) {
     return {
       source: "external",
       thread,
-      timestamp: input.query.sortKey === "created_at" ? unixTimestamp(record4.createdAt, "createdAt") : unixTimestamp(record4.updatedAt, "updatedAt")
+      timestamp: input.query.sortKey === "created_at" ? unixTimestamp(record5.createdAt, "createdAt") : unixTimestamp(record5.updatedAt, "updatedAt")
     };
   });
 }
@@ -37811,7 +38568,7 @@ async function aggregateThreadList(input) {
   let officialIndex = 0;
   let firstOfficialBackwardsCursor;
   let officialRequestCount = 0;
-  const externalIds = new Set(input.records.map((record4) => record4.hostThreadId));
+  const externalIds = new Set(input.records.map((record5) => record5.hostThreadId));
   for (const thread of input.sharedThreads ?? []) externalIds.add(String(thread.id));
   const requestOfficial = async (cursor, limit) => {
     officialRequestCount += 1;
@@ -38153,7 +38910,6 @@ async function moveThreadSection(input) {
 // packages/host-runtime/src/external-thread-official-defaults.ts
 var EMPTY_RESULTS = /* @__PURE__ */ new Map([
   ["thread/attachment/list", () => ({ data: [], nextCursor: null })],
-  ["thread/queue/list", () => ({ data: [], nextCursor: null })],
   ["thread/settings/update", () => ({})]
 ]);
 function externalThreadEmptyOfficialResult(method) {
@@ -38503,6 +39259,9 @@ var AppServerHost = class {
   #executionHosts = /* @__PURE__ */ new WeakMap();
   #externalPrewarms = new ExternalThreadPrewarms();
   #externalSteering = new ExternalTurnSteering();
+  #externalQueue = new ExternalThreadQueue({
+    notifyChanged: (threadId2) => this.#writer.json({ method: "thread/queue/changed", params: { threadId: threadId2 } })
+  });
   #liveCommandCache = new LiveCommandCatalogCache();
   #modelPrices;
   #observedSessionUsage;
@@ -38529,7 +39288,7 @@ var AppServerHost = class {
   #sectionMoves = Promise.resolve();
   #writer;
   /** Console requests share Desktop handling; their replies return to the console. */
-  #consoleRequestPrefix = `codexhost-console:${randomUUID16()}:`;
+  #consoleRequestPrefix = `codexhost-console:${randomUUID17()}:`;
   #consoleReplies = /* @__PURE__ */ new Map();
   #nextConsoleRequest = 0;
   #subagentThreadStatuses = /* @__PURE__ */ new Map();
@@ -38638,16 +39397,7 @@ var AppServerHost = class {
       hasRunningDescendants: (threadId2) => this.#hasRunningSubagents(threadId2),
       idleRelease: {
         queue: this.#desktopRequests,
-        onClosed: async (thread) => {
-          for (const pending of [...this.#pendingDesktopApprovals.values()]) {
-            if (pending.thread === thread)
-              await this.#resolveDesktopApproval(pending.interaction.interactionId);
-          }
-          for (const pending of [...this.#pendingDesktopQuestions.values()]) {
-            if (pending.thread === thread)
-              await this.#resolveDesktopQuestion(pending.interaction.interactionId);
-          }
-        },
+        onClosed: (thread) => this.#resolveThreadInteractions(thread),
         canRelease: (thread) => !this.#hasRunningSubagents(thread.id) && !thread.session.hasBackgroundWork?.() && !this.#externalSteering.hasPending(thread.id) && !this.#pendingExternalCommandRequests.has(thread.id) && ![...this.#pendingDesktopApprovals.values()].some(
           (pending) => pending.thread === thread
         ) && ![...this.#pendingDesktopQuestions.values()].some((pending) => pending.thread === thread)
@@ -38837,12 +39587,12 @@ var AppServerHost = class {
       await this.#closeAdapters();
       await this.#externalRuntime.drain();
       for (const pending of [...this.#pendingDesktopApprovals.values()]) {
-        await this.#resolveDesktopApproval(pending.interaction.interactionId).catch(
+        await this.#resolveDesktopApproval(pending.interaction.interactionId, pending.thread).catch(
           () => void 0
         );
       }
       for (const pending of [...this.#pendingDesktopQuestions.values()]) {
-        await this.#resolveDesktopQuestion(pending.interaction.interactionId).catch(
+        await this.#resolveDesktopQuestion(pending.interaction.interactionId, pending.thread).catch(
           () => void 0
         );
       }
@@ -39766,6 +40516,18 @@ var AppServerHost = class {
         return;
       }
     }
+    if (request.method.startsWith("thread/queue/") && isRecord18(request.params) && typeof request.params.threadId === "string") {
+      const location = await this.#locateExternalThread(request.params.threadId);
+      if (await this.#writeResolutionError(request, location)) return;
+      if (location.kind === "external") {
+        this.#dispatchDesktopReply(
+          request,
+          () => this.#handleExternalQueueRequest(request, location.record.hostThreadId),
+          location.record.hostThreadId
+        );
+        return;
+      }
+    }
     if (request.method === "thread/backgroundTerminals/clean" && isRecord18(request.params) && typeof request.params.threadId === "string") {
       const location = await this.#locateExternalThread(request.params.threadId);
       if (await this.#writeResolutionError(request, location)) return;
@@ -40176,7 +40938,7 @@ var AppServerHost = class {
       throw error51;
     }
     this.#activeOfficialTurns.set(threadId2, turnId);
-    const delegationId = hostThreadIdSchema.parse(randomUUID16());
+    const delegationId = hostThreadIdSchema.parse(randomUUID17());
     try {
       const source = await this.#repository.find(input.parentThreadId);
       const pendingTerminal = this.#pendingOfficialTerminalStatuses.get(threadId2);
@@ -40364,7 +41126,7 @@ var AppServerHost = class {
   async #listDelegationThreads(input) {
     const [sortKey, sortDirection2] = input.sort.split("-");
     const request = {
-      id: `codexhost:delegation-list:${randomUUID16()}`,
+      id: `codexhost:delegation-list:${randomUUID17()}`,
       method: "thread/list",
       params: {
         cwd: input.cwd ? [input.cwd] : null,
@@ -40389,12 +41151,12 @@ var AppServerHost = class {
     return {
       threads: result.data.flatMap((entry) => {
         if (typeof entry.id !== "string") return [];
-        const record4 = records.find((candidate) => candidate.hostThreadId === entry.id);
+        const record5 = records.find((candidate) => candidate.hostThreadId === entry.id);
         const status2 = isRecord18(entry.status) && entry.status.type === "active" ? "running" : "completed";
         return [
           {
             threadId: entry.id,
-            harnessId: record4 ? record4.harnessId : "codex",
+            harnessId: record5 ? record5.harnessId : "codex",
             deepLink: `codex://threads/${entry.id}`,
             status: status2,
             ...typeof entry.cwd === "string" ? { cwd: entry.cwd } : {},
@@ -40501,7 +41263,7 @@ var AppServerHost = class {
       const outcome = await moveThreadSection({
         move,
         movingExternal: location.kind === "external",
-        externalThreadIds: new Set(records.map((record4) => record4.hostThreadId)),
+        externalThreadIds: new Set(records.map((record5) => record5.hostThreadId)),
         placements,
         requestOfficial: (method, params) => this.#requestOfficial(method, params),
         savePlacements: (next) => this.#repository.replaceSectionPlacements(next),
@@ -40591,10 +41353,10 @@ var AppServerHost = class {
   /** Clear External assignments to a project official Codex reported as deleted. */
   async #clearDeletedProjectAssignments(projectId) {
     const records = await this.#repository.list();
-    for (const record4 of records) {
-      if (record4.projectId !== projectId) continue;
+    for (const record5 of records) {
+      if (record5.projectId !== projectId) continue;
       const updated = await this.#repository.updateMetadata(
-        record4.hostThreadId,
+        record5.hostThreadId,
         { projectId: null },
         { ifProjectId: projectId }
       );
@@ -40607,14 +41369,14 @@ var AppServerHost = class {
       });
     }
   }
-  #syncLoadedExternalThread(thread, record4) {
+  #syncLoadedExternalThread(thread, record5) {
     const projected = externalThreadValue({
-      record: record4,
+      record: record5,
       turns: [],
       sessionId: thread.sessionId,
       running: thread.running
     });
-    thread.record = record4;
+    thread.record = record5;
     thread.thread = { ...thread.thread, ...projected, turns: thread.thread.turns ?? [] };
     return projected;
   }
@@ -40631,15 +41393,15 @@ var AppServerHost = class {
       );
       return null;
     }
-    let record4;
+    let record5;
     try {
-      record4 = await write(location.record.hostThreadId);
+      record5 = await write(location.record.hostThreadId);
     } catch {
       await this.#writer.json(rpcError(request, -32081, failureMessage));
       return null;
     }
-    const projected = location.thread ? this.#syncLoadedExternalThread(location.thread, record4) : externalThreadValue({ record: record4, turns: [], sessionId, loaded: false });
-    return { record: record4, thread: await this.#withExternalSection(projected) };
+    const projected = location.thread ? this.#syncLoadedExternalThread(location.thread, record5) : externalThreadValue({ record: record5, turns: [], sessionId, loaded: false });
+    return { record: record5, thread: await this.#withExternalSection(projected) };
   }
   async #handleConsoleOpen(request) {
     if (!consoleOpenParamsSchema.safeParse(request.params ?? {}).success) {
@@ -40895,8 +41657,8 @@ var AppServerHost = class {
           const sharedHarness = shared?.get(threadId2);
           if (sharedHarness)
             return { threadId: threadId2, owner: "external", harnessId: sharedHarness };
-          const record4 = await this.#repository.find(threadId2);
-          return record4 ? { threadId: threadId2, owner: "external", harnessId: record4.harnessId } : { threadId: threadId2, owner: "codex" };
+          const record5 = await this.#repository.find(threadId2);
+          return record5 ? { threadId: threadId2, owner: "external", harnessId: record5.harnessId } : { threadId: threadId2, owner: "codex" };
         })
       );
       const result = threadOwnershipListResultSchema.parse({ threads });
@@ -41092,7 +41854,7 @@ var AppServerHost = class {
     if (thread.running || thread.activeTurnId) {
       throw new ExternalCommandError(-32072, "External Thread already has an active operation");
     }
-    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID16());
+    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID17());
     const projection = {
       projector: new CodexTurnProjector({
         threadId: thread.id,
@@ -41407,6 +42169,7 @@ var AppServerHost = class {
     }
     const params = requestObject(request);
     const route = decodeCreateRoute(request);
+    const prewarm = params[EXTERNAL_THREAD_PREWARM_PARAM] === true || route?.prewarm === true;
     const requestedModel = route && route.harnessId !== "codex" ? route.model : void 0;
     const requestedThinkingOptionId = route && route.harnessId !== "codex" ? route.thinkingOptionId : void 0;
     const requestedPermissionModeId = route && route.harnessId !== "codex" ? route.permissionModeId : void 0;
@@ -41426,9 +42189,9 @@ var AppServerHost = class {
       ephemeral: params.ephemeral === true,
       historyMode: params.historyMode === "paginated" ? "paginated" : "legacy"
     });
-    let record4;
+    let record5;
     try {
-      record4 = await this.#repository.createProvisional(recordInput);
+      record5 = await this.#repository.createProvisional(recordInput);
     } catch {
       this.#routeObservationTracker.rejectCreate(request.id);
       await this.#writer.json(rpcError(request, -32081, "External Thread could not be persisted"));
@@ -41439,7 +42202,7 @@ var AppServerHost = class {
       cwd,
       environment: {
         ...this.#options.environment ?? process.env,
-        [DELEGATION_THREAD_ID_ENV]: record4.hostThreadId
+        [DELEGATION_THREAD_ID_ENV]: record5.hostThreadId
       },
       ...requestedModel ? { model: requestedModel } : {},
       ...requestedThinkingOptionId ? { thinkingOptionId: requestedThinkingOptionId } : {},
@@ -41447,37 +42210,37 @@ var AppServerHost = class {
     });
     if (!sessionResult.ok) {
       this.#routeObservationTracker.rejectCreate(request.id);
-      await this.#repository.removeProvisional(record4.hostThreadId).catch(() => void 0);
+      await this.#repository.removeProvisional(record5.hostThreadId).catch(() => void 0);
       const mapped = mapExternalThreadHarnessError(sessionResult.error, "create");
       await this.#writer.json(rpcError(request, mapped.code, mapped.message));
       return;
     }
     const session = sessionResult.value;
-    await this.#externalRuntime.idleRelease.runOperation(record4.hostThreadId, async () => {
+    await this.#externalRuntime.idleRelease.runOperation(record5.hostThreadId, async () => {
       try {
-        if (session.initialState.nativeRef && params[EXTERNAL_THREAD_PREWARM_PARAM] !== true) {
-          record4 = await this.#repository.commitNative(
-            record4.hostThreadId,
+        if (session.initialState.nativeRef && !prewarm) {
+          record5 = await this.#repository.commitNative(
+            record5.hostThreadId,
             session.initialState.nativeRef
           );
         }
         const thread = externalThreadValue({
-          record: record4,
+          record: record5,
           turns: [],
-          sessionId: record4.hostThreadId
+          sessionId: record5.hostThreadId
         });
         const externalThread = this.#registerExternalThread({
-          record: record4,
+          record: record5,
           session,
-          unsubmittedPrewarm: params[EXTERNAL_THREAD_PREWARM_PARAM] === true,
-          sessionId: record4.hostThreadId,
+          unsubmittedPrewarm: prewarm,
+          sessionId: record5.hostThreadId,
           thread,
           turns: [],
           ...requestedModel ? { requestedModel } : {},
           ...requestedThinkingOptionId ? { requestedThinkingOptionId } : {},
           ...requestedPermissionModeId ? { requestedPermissionModeId } : {}
         });
-        if (params[EXTERNAL_THREAD_PREWARM_PARAM] === true) {
+        if (prewarm) {
           this.#externalPrewarms.register(externalThread);
         }
         this.#routeObservationTracker.bindCreatedThread(request.id, externalThread.id);
@@ -41500,12 +42263,12 @@ var AppServerHost = class {
             }
           })
         );
-        if (record4.state === "ready") await this.#notifyExternalThreadStarted(thread);
+        if (record5.state === "ready") await this.#notifyExternalThreadStarted(thread);
       } catch {
-        this.#externalRuntime.remove(record4.hostThreadId);
-        this.#routeObservationTracker.forgetThread(record4.hostThreadId);
+        this.#externalRuntime.remove(record5.hostThreadId);
+        this.#routeObservationTracker.forgetThread(record5.hostThreadId);
         await session.close().catch(() => void 0);
-        await this.#repository.removeProvisional(record4.hostThreadId).catch(() => void 0);
+        await this.#repository.removeProvisional(record5.hostThreadId).catch(() => void 0);
         await this.#writer.json(
           rpcError(request, -32081, "External Thread could not be persisted")
         );
@@ -41667,9 +42430,9 @@ var AppServerHost = class {
       );
       return;
     }
-    let record4;
+    let record5;
     try {
-      record4 = await this.#repository.setTitle(location.record.hostThreadId, name);
+      record5 = await this.#repository.setTitle(location.record.hostThreadId, name);
     } catch {
       await this.#writer.json(
         rpcError(request, -32081, "External Thread title could not be persisted")
@@ -41677,7 +42440,7 @@ var AppServerHost = class {
       return;
     }
     if (location.thread) {
-      location.thread.record = record4;
+      location.thread.record = record5;
       location.thread.thread.name = name;
       location.thread.thread.updatedAt = unixSeconds();
     }
@@ -41688,29 +42451,24 @@ var AppServerHost = class {
     });
   }
   async #deleteExternalThread(request, location) {
-    const thread = location.thread;
     try {
-      await this.#repository.removeThread(location.record.hostThreadId);
-    } catch {
-      await this.#writer.json(rpcError(request, -32081, "External Thread could not be removed"));
-      return;
-    }
-    this.#externalRuntime.remove(location.record.hostThreadId);
-    this.#routeObservationTracker.forgetThread(location.record.hostThreadId);
-    if (!thread) {
-      await this.#writer.json(rpcEnvelope(request, { result: {} }));
-      return;
-    }
-    thread.stateObserver.fault(new Error("External Thread was deleted"));
-    try {
-      await thread.session.close();
-      await thread.outputTask;
-      await this.#writer.json(rpcEnvelope(request, { result: {} }));
+      await this.#externalRuntime.deleteThread(location.record.hostThreadId);
     } catch (error51) {
+      if (!(error51 instanceof ExternalSessionReleaseError) && location.thread)
+        await this.#resolveThreadInteractions(location.thread);
       await this.#writer.json(
-        rpcError(request, -32075, `External Thread could not close: ${errorMessage4(error51)}`)
+        error51 instanceof ExternalSessionReleaseError ? rpcError(request, -32075, error51.message) : rpcError(request, -32081, "External Thread could not be removed")
       );
+      return;
     }
+    if (location.thread) await this.#resolveThreadInteractions(location.thread);
+    this.#routeObservationTracker.forgetThread(location.record.hostThreadId);
+    this.#externalQueue.forget(location.record.hostThreadId);
+    await this.#writer.json(rpcEnvelope(request, { result: {} }));
+    await this.#writer.json({
+      method: "thread/deleted",
+      params: { threadId: location.record.hostThreadId }
+    });
   }
   async #readExternalThreadMetadata(request, location) {
     try {
@@ -41959,6 +42717,125 @@ var AppServerHost = class {
       );
     }
   }
+  async #handleExternalQueueRequest(request, threadId2) {
+    const queue = this.#externalQueue;
+    try {
+      const params = requestObject(request);
+      const input = () => {
+        requestText(params);
+        return params.input;
+      };
+      const submissionId = () => {
+        if (typeof params.queuedSubmissionId !== "string")
+          throw new ExternalQueueError(-32602, "queuedSubmissionId must be a string");
+        return params.queuedSubmissionId;
+      };
+      let result;
+      switch (request.method) {
+        case "thread/queue/list":
+          result = queue.list(threadId2, params);
+          break;
+        case "thread/queue/add": {
+          if (typeof params.clientUserMessageId !== "string" || !params.clientUserMessageId)
+            throw new ExternalQueueError(-32602, "clientUserMessageId must be a string");
+          const sourceHostId = params[THREAD_REFERENCE_SOURCE_HOST_PARAM];
+          const submission = await queue.add(
+            threadId2,
+            input(),
+            params.clientUserMessageId,
+            typeof sourceHostId === "string" ? sourceHostId : void 0
+          );
+          result = { queuedSubmission: submission };
+          break;
+        }
+        case "thread/queue/update": {
+          const submission = await queue.update(threadId2, submissionId(), input());
+          result = { queuedSubmission: submission };
+          break;
+        }
+        case "thread/queue/delete":
+          result = { deleted: await queue.delete(threadId2, submissionId()) };
+          break;
+        case "thread/queue/reorder": {
+          const ids = params.queuedSubmissionIds;
+          if (!Array.isArray(ids) || !ids.every((id2) => typeof id2 === "string"))
+            throw new ExternalQueueError(-32602, "queuedSubmissionIds must be strings");
+          await queue.reorder(threadId2, ids);
+          result = {};
+          break;
+        }
+        case "thread/queue/start": {
+          const resolution = await this.#resolveExternalThread(threadId2);
+          if (await this.#writeResolutionError(request, resolution)) return;
+          if (resolution.kind !== "external")
+            throw new ExternalQueueError(-32073, "External Thread is no longer available");
+          const started = await this.#startQueuedSubmission(
+            resolution.thread,
+            params.queuedSubmissionId == null ? null : submissionId()
+          );
+          try {
+            await this.#writer.json(rpcEnvelope(request, { result: { turn: started.turn } }));
+          } finally {
+            started.gate.resolve();
+          }
+          return;
+        }
+        default:
+          throw new ExternalQueueError(
+            -32076,
+            `External Thread does not support ${request.method}`
+          );
+      }
+      await this.#writer.json(rpcEnvelope(request, { result }));
+      if (request.method === "thread/queue/add") {
+        const thread = this.#externalRuntime.get(threadId2);
+        const lastTurn = thread?.turns.at(-1);
+        if (thread && thread.projectedTerminalTurnId === lastTurn?.id && lastTurn?.status === "completed" && isRecord18(thread.thread.status) && thread.thread.status.type === "idle") {
+          void this.#drainExternalQueue(thread);
+        }
+      }
+    } catch (error51) {
+      await this.#writer.json(
+        rpcError(
+          request,
+          error51 instanceof ExternalQueueError || error51 instanceof ExternalSteerError || error51 instanceof ExternalCommandError ? error51.code : -32602,
+          errorMessage4(error51)
+        )
+      );
+    }
+  }
+  /** Starts a queued follow-up as a Turn; it returns to its place when the start fails. */
+  async #startQueuedSubmission(thread, submissionId) {
+    if (this.#externalThreadBusy(thread) || this.#pendingExternalCommandRequests.has(thread.id))
+      throw new ExternalSteerError(-32072, "External Thread already has an active Turn");
+    const taken = this.#externalQueue.take(thread.id, submissionId);
+    try {
+      const started = await this.#beginExternalInputTurn(
+        thread,
+        requestText({ input: taken.submission.input }),
+        void 0,
+        taken.submission.clientUserMessageId,
+        taken.sourceHostId,
+        true
+      );
+      await this.#externalQueue.notifyChanged(thread.id);
+      return started;
+    } catch (error51) {
+      this.#externalQueue.restore(thread.id, taken);
+      await this.#externalQueue.notifyChanged(thread.id);
+      throw error51;
+    }
+  }
+  /** Desktop leaves queued follow-ups to the app-server once a Turn completes normally. */
+  async #drainExternalQueue(thread) {
+    if (!this.#externalQueue.has(thread.id) || this.#externalThreadBusy(thread) || this.#pendingExternalCommandRequests.has(thread.id))
+      return;
+    try {
+      (await this.#startQueuedSubmission(thread)).gate.resolve();
+    } catch (error51) {
+      this.#diagnose(error51);
+    }
+  }
   async #steerExternalTurn(request, thread) {
     try {
       const started = await this.#externalSteering.run(
@@ -42023,12 +42900,12 @@ var AppServerHost = class {
     };
   }
   /** Keep command restoration and dispatch identical for start and steer submissions. */
-  async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId, sourceHostId) {
+  async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId, sourceHostId, projectInput = false) {
     const text = restoreHarnessCommandMentions(inputText);
     const commands = thread.session.commands;
     if (!commands || !isExternalCommandCandidate(text)) {
       assertActive?.();
-      return this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId);
+      return this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId, projectInput);
     }
     this.#pendingExternalCommandRequests.add(thread.id);
     try {
@@ -42039,7 +42916,13 @@ var AppServerHost = class {
       assertActive?.();
       if (!command) {
         this.#pendingExternalCommandRequests.delete(thread.id);
-        return await this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId);
+        return await this.#beginExternalTurn(
+          thread,
+          text,
+          clientUserMessageId,
+          sourceHostId,
+          projectInput
+        );
       }
       return await this.#beginExternalCommand(
         thread,
@@ -42072,14 +42955,18 @@ var AppServerHost = class {
       else this.#executionHosts.set(thread, previousHostId);
     };
   }
-  async #beginExternalTurn(thread, text, clientUserMessageId, sourceHostId) {
+  /**
+   * Desktop renders the input of its own `turn/start` locally. Other starts (Host-only clients
+   * and queued follow-ups) need the user message projected with the Turn.
+   */
+  async #beginExternalTurn(thread, text, clientUserMessageId, sourceHostId, projectInput = false) {
     if (this.#closeRequested || this.#externalRuntime.get(thread.id) !== thread) {
       throw new ExternalSteerError(-32073, "External Thread is no longer available");
     }
     if (thread.running || thread.activeTurnId || this.#pendingExternalCommandRequests.has(thread.id)) {
       throw new ExternalSteerError(-32072, "External Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID16());
+    const turnId = hostTurnIdSchema.parse(randomUUID17());
     const startedAtMs = Date.now();
     const projection = {
       projector: new CodexTurnProjector({
@@ -42087,7 +42974,7 @@ var AppServerHost = class {
         turnId,
         cwd: thread.cwd,
         startedAtMs,
-        ...this.#options.externalOnly ? {
+        ...this.#options.externalOnly || projectInput ? {
           initialInput: [{ type: "text", text }],
           ...clientUserMessageId ? { clientUserMessageId } : {}
         } : {}
@@ -42318,21 +43205,21 @@ var AppServerHost = class {
     }
     if (event.type === "subagent.transcript.changed") {
       const nativeSubagentId = event.nativeSubagentId;
-      const record4 = (await this.#repository.list()).find(
+      const record5 = (await this.#repository.list()).find(
         (candidate) => candidate.subagent?.parentHostThreadId === thread.id && candidate.subagent.nativeSubagentId === nativeSubagentId && candidate.nativeSessionRef?.nativeSessionId === thread.record.nativeSessionRef?.nativeSessionId
       );
-      if (record4) await this.#refreshOpenSubagentThread(record4.hostThreadId, false);
+      if (record5) await this.#refreshOpenSubagentThread(record5.hostThreadId, false);
       return;
     }
     if (event.type === "subagent.state.changed") {
       const nativeSubagentId = event.nativeSubagentId;
-      const record4 = (await this.#repository.list()).find(
+      const record5 = (await this.#repository.list()).find(
         (candidate) => candidate.subagent?.parentHostThreadId === thread.id && candidate.subagent.nativeSubagentId === nativeSubagentId && candidate.nativeSessionRef?.nativeSessionId === thread.record.nativeSessionRef?.nativeSessionId
       );
-      if (!record4) return;
+      if (!record5) return;
       const status2 = event.status === "pending" || event.status === "running" ? "active" : "idle";
-      this.#trackRunningSubagent(thread.id, record4.hostThreadId, status2);
-      await this.#setSubagentThreadStatus(record4.hostThreadId, status2);
+      this.#trackRunningSubagent(thread.id, record5.hostThreadId, status2);
+      await this.#setSubagentThreadStatus(record5.hostThreadId, status2);
       if (!thread.running && !thread.activeTurnId && !this.#hasRunningSubagents(thread.id)) {
         await this.#setThreadStatus(thread, { type: "idle" });
       }
@@ -42341,7 +43228,7 @@ var AppServerHost = class {
     if (event.type === "session.faulted") {
       for (const pending of [...this.#pendingDesktopQuestions.values()]) {
         if (pending.shared && pending.thread === thread)
-          this.#retireDesktopQuestion(pending.interaction.interactionId);
+          this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
       }
       this.#externalSteering.fault(thread.id, new Error(event.error.message));
       thread.stateObserver.fault(new Error(event.error.message));
@@ -42389,12 +43276,12 @@ var AppServerHost = class {
     if (event.type === "turn.completed") {
       for (const pending of [...this.#pendingDesktopQuestions.values()]) {
         if (pending.shared && pending.thread === thread && pending.interaction.turnId === event.turnId)
-          this.#retireDesktopQuestion(pending.interaction.interactionId);
+          this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
       }
     }
     if (event.type === "interaction.closed") {
-      await this.#resolveDesktopApproval(event.interactionId);
-      await this.#resolveDesktopQuestion(event.interactionId);
+      await this.#resolveDesktopApproval(event.interactionId, thread);
+      await this.#resolveDesktopQuestion(event.interactionId, thread);
     }
     const ephemeralTurn = event.type === "turn.completed" && (event.ephemeral === true || thread.ephemeralTurnIds.has(event.turnId));
     if (event.type === "turn.completed" && !ephemeralTurn) {
@@ -42460,32 +43347,35 @@ var AppServerHost = class {
         this.#hasRunningSubagents(thread.id) ? { type: "active", activeFlags: [] } : { type: "idle" }
       );
       this.#externalSteering.terminal(thread.id, event.turnId, event.outcome);
+      if (!ephemeralTurn && result.completedTurn?.status === "completed" && this.#externalQueue.has(thread.id)) {
+        void this.#drainExternalQueue(thread);
+      }
     }
   }
   async #materializeSubagent(parent, subagent) {
     if (!subagent.nativeSubagentId || !parent.record.nativeSessionRef) return subagent;
     const status2 = subagent.status === "pending" || subagent.status === "running" ? "active" : "idle";
-    const record4 = await this.#repository.materializeSubagent(parent.record, subagent);
-    if (!record4) return subagent;
-    if (this.#subagentThreadStatuses.has(record4.hostThreadId)) {
-      this.#trackRunningSubagent(parent.id, record4.hostThreadId, status2);
-      await this.#setSubagentThreadStatus(record4.hostThreadId, status2);
-      return { ...subagent, subagentId: record4.hostThreadId };
+    const record5 = await this.#repository.materializeSubagent(parent.record, subagent);
+    if (!record5) return subagent;
+    if (this.#subagentThreadStatuses.has(record5.hostThreadId)) {
+      this.#trackRunningSubagent(parent.id, record5.hostThreadId, status2);
+      await this.#setSubagentThreadStatus(record5.hostThreadId, status2);
+      return { ...subagent, subagentId: record5.hostThreadId };
     }
     const thread = externalThreadValue({
-      record: record4,
+      record: record5,
       turns: [],
       sessionId: parent.sessionId,
       running: status2 === "active"
     });
-    this.#subagentThreadStatuses.set(record4.hostThreadId, status2);
-    this.#trackRunningSubagent(parent.id, record4.hostThreadId, status2);
+    this.#subagentThreadStatuses.set(record5.hostThreadId, status2);
+    this.#trackRunningSubagent(parent.id, record5.hostThreadId, status2);
     await this.#writer.json({
       method: "thread/started",
       emittedAtMs: Date.now(),
       params: { thread }
     });
-    return { ...subagent, subagentId: record4.hostThreadId };
+    return { ...subagent, subagentId: record5.hostThreadId };
   }
   async #refreshOpenSubagentThread(threadId2, terminal3 = true) {
     await this.#desktopRequests.run(threadId2, async () => {
@@ -42651,7 +43541,7 @@ var AppServerHost = class {
       if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
         return true;
       if (this.#options.externalOnly)
-        await this.#resolveDesktopApproval(pending.interaction.interactionId);
+        await this.#resolveDesktopApproval(pending.interaction.interactionId, pending.thread);
       else this.#pendingDesktopApprovals.delete(requestId);
       let response;
       try {
@@ -42702,9 +43592,20 @@ var AppServerHost = class {
     }
     return denied.ok;
   }
-  async #resolveDesktopApproval(interactionId) {
+  async #resolveThreadInteractions(thread) {
+    for (const pending of [...this.#pendingDesktopApprovals.values()]) {
+      if (pending.thread === thread)
+        await this.#resolveDesktopApproval(pending.interaction.interactionId, thread);
+    }
+    for (const pending of [...this.#pendingDesktopQuestions.values()]) {
+      if (pending.thread === thread)
+        await this.#resolveDesktopQuestion(pending.interaction.interactionId, thread);
+    }
+  }
+  async #resolveDesktopApproval(interactionId, thread) {
     for (const [requestId, pending] of this.#pendingDesktopApprovals) {
-      if (pending.interaction.interactionId !== interactionId) continue;
+      if (pending.thread !== thread || pending.interaction.interactionId !== interactionId)
+        continue;
       this.#pendingDesktopApprovals.delete(requestId);
       await this.#writer.json({
         method: "serverRequest/resolved",
@@ -42763,16 +43664,16 @@ var AppServerHost = class {
             response
           });
         } catch (error51) {
-          this.#retireDesktopQuestion(pending.interaction.interactionId);
+          this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
           throw error51;
         }
         if (!result.ok) {
           pending.responding = false;
           if (result.error.code === "invalidState")
-            this.#retireDesktopQuestion(pending.interaction.interactionId);
+            this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
           throw new Error(result.error.message);
         }
-        this.#retireDesktopQuestion(pending.interaction.interactionId);
+        this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
         await this.#writer.json(rpcEnvelope(request, { result: { accepted: true } }));
       });
     } catch (error51) {
@@ -42788,7 +43689,7 @@ var AppServerHost = class {
       if (shared) sharedQuestion(interaction);
       result = projection.projector.projectQuestion(
         interaction,
-        hostItemIdSchema.parse(randomUUID16())
+        hostItemIdSchema.parse(randomUUID17())
       );
     } catch (error51) {
       this.#diagnose(error51);
@@ -42826,7 +43727,7 @@ var AppServerHost = class {
     try {
       await this.#writer.json({ id: requestId, ...result.questionRequest.request });
     } catch (error51) {
-      this.#retireDesktopQuestion(interaction.interactionId);
+      this.#retireDesktopQuestion(interaction.interactionId, thread);
       await thread.session.execute({
         type: "interaction.respond",
         interactionId: interaction.interactionId,
@@ -42844,7 +43745,7 @@ var AppServerHost = class {
       if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
         return true;
       if (this.#options.externalOnly)
-        await this.#resolveDesktopQuestion(pending.interaction.interactionId);
+        await this.#resolveDesktopQuestion(pending.interaction.interactionId, pending.thread);
       else this.#pendingDesktopQuestions.delete(requestId);
       if (pending.timeout) clearTimeout(pending.timeout);
       let response;
@@ -42871,7 +43772,7 @@ var AppServerHost = class {
     await this.#externalRuntime.idleRelease.runOperation(pending.thread.id, async () => {
       if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
         return;
-      await this.#resolveDesktopQuestion(pending.interaction.interactionId);
+      await this.#resolveDesktopQuestion(pending.interaction.interactionId, pending.thread);
       if (pending.responding) return;
       const result = await pending.thread.session.execute({
         type: "interaction.respond",
@@ -42883,16 +43784,18 @@ var AppServerHost = class {
       }
     });
   }
-  #retireDesktopQuestion(interactionId) {
+  #retireDesktopQuestion(interactionId, thread) {
     for (const [requestId, pending] of this.#pendingDesktopQuestions) {
-      if (pending.interaction.interactionId !== interactionId) continue;
+      if (pending.thread !== thread || pending.interaction.interactionId !== interactionId)
+        continue;
       if (pending.timeout) clearTimeout(pending.timeout);
       this.#pendingDesktopQuestions.delete(requestId);
     }
   }
-  async #resolveDesktopQuestion(interactionId) {
+  async #resolveDesktopQuestion(interactionId, thread) {
     for (const [requestId, pending] of this.#pendingDesktopQuestions) {
-      if (pending.interaction.interactionId !== interactionId) continue;
+      if (pending.thread !== thread || pending.interaction.interactionId !== interactionId)
+        continue;
       if (pending.timeout) clearTimeout(pending.timeout);
       this.#pendingDesktopQuestions.delete(requestId);
       if (pending.shared) continue;
@@ -43032,7 +43935,7 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // packages/host-runtime/src/remote-socket-lock.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import { chmod as chmod3, lstat as lstat5, mkdir as mkdir12, open as open9, readFile as readFile16, readdir as readdir5, rename as rename11, rm as rm11 } from "node:fs/promises";
 import { uptime } from "node:os";
 import path26 from "node:path";
@@ -43046,18 +43949,18 @@ var LOCK_ENTRY_SUFFIX = ".json";
 function currentBootTimeSeconds() {
   return Math.round(Date.now() / 1e3 - uptime());
 }
-function validOwnerFields(record4) {
-  return typeof record4.ownerToken === "string" && record4.ownerToken.length > 0 && typeof record4.pid === "number" && Number.isSafeInteger(record4.pid) && record4.pid > 0 && typeof record4.bootTimeSeconds === "number" && Number.isSafeInteger(record4.bootTimeSeconds);
+function validOwnerFields(record5) {
+  return typeof record5.ownerToken === "string" && record5.ownerToken.length > 0 && typeof record5.pid === "number" && Number.isSafeInteger(record5.pid) && record5.pid > 0 && typeof record5.bootTimeSeconds === "number" && Number.isSafeInteger(record5.bootTimeSeconds);
 }
 function parseLockRecord(source) {
   try {
     const value2 = JSON.parse(source);
     if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) return null;
-    const record4 = value2;
-    if (record4.version !== 2 || !validOwnerFields(record4) || typeof record4.choosing !== "boolean" || typeof record4.ticket !== "number" || !Number.isSafeInteger(record4.ticket) || record4.ticket < 0 || (record4.choosing ? record4.ticket !== 0 : record4.ticket === 0)) {
+    const record5 = value2;
+    if (record5.version !== 2 || !validOwnerFields(record5) || typeof record5.choosing !== "boolean" || typeof record5.ticket !== "number" || !Number.isSafeInteger(record5.ticket) || record5.ticket < 0 || (record5.choosing ? record5.ticket !== 0 : record5.ticket === 0)) {
       return null;
     }
-    return record4;
+    return record5;
   } catch {
     return null;
   }
@@ -43066,9 +43969,9 @@ function parseLegacyLockRecord(source) {
   try {
     const value2 = JSON.parse(source);
     if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) return null;
-    const record4 = value2;
-    if (record4.version !== 1 || !validOwnerFields(record4)) return null;
-    return record4;
+    const record5 = value2;
+    if (record5.version !== 1 || !validOwnerFields(record5)) return null;
+    return record5;
   } catch {
     return null;
   }
@@ -43081,10 +43984,10 @@ function processIsRunning(pid) {
     return error51.code !== "ESRCH";
   }
 }
-function ownerIsAbandoned(record4, mtimeMs) {
-  if (Math.abs(record4.bootTimeSeconds - currentBootTimeSeconds()) > 5) return true;
+function ownerIsAbandoned(record5, mtimeMs) {
+  if (Math.abs(record5.bootTimeSeconds - currentBootTimeSeconds()) > 5) return true;
   if (Math.max(0, Date.now() - mtimeMs) >= LOCK_MAX_AGE_MS) return true;
-  return !processIsRunning(record4.pid);
+  return !processIsRunning(record5.pid);
 }
 function sameUnixFileIdentity(left, right) {
   return left.dev === right.dev && left.ino === right.ino;
@@ -43103,13 +44006,13 @@ async function readLockEntrySnapshot(filePath) {
     throw error51;
   });
   if (source === null) return null;
-  const record4 = parseLockRecord(source);
+  const record5 = parseLockRecord(source);
   return {
     filePath,
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record4 && path26.basename(filePath) === lockEntryName(record4.ownerToken) ? record4 : null
+    record: record5 && path26.basename(filePath) === lockEntryName(record5.ownerToken) ? record5 : null
   };
 }
 function lockEntryIsAbandoned(snapshot2) {
@@ -43157,11 +44060,11 @@ async function preparePrivateLockDirectory(lockDirectory) {
   }
   await chmod3(lockDirectory, 448);
 }
-async function writeLockRecordAtomic(lockDirectory, entryPath, record4) {
-  const temporary = path26.join(lockDirectory, `.tmp-${record4.ownerToken}-${randomUUID17()}`);
+async function writeLockRecordAtomic(lockDirectory, entryPath, record5) {
+  const temporary = path26.join(lockDirectory, `.tmp-${record5.ownerToken}-${randomUUID18()}`);
   const handle = await open9(temporary, "wx", 384);
   try {
-    await handle.writeFile(`${JSON.stringify(record4)}
+    await handle.writeFile(`${JSON.stringify(record5)}
 `, "utf8");
     await handle.sync();
   } finally {
@@ -43191,11 +44094,11 @@ async function legacyLockState(legacyPath) {
   });
   if (source === null) return "absent";
   const ageMs = Math.max(0, Date.now() - metadata.mtimeMs);
-  const record4 = parseLegacyLockRecord(source);
-  if (record4 === null) return ageMs < LOCK_MALFORMED_GRACE_MS ? "blocking" : "abandoned";
-  return ownerIsAbandoned(record4, metadata.mtimeMs) ? "abandoned" : "blocking";
+  const record5 = parseLegacyLockRecord(source);
+  if (record5 === null) return ageMs < LOCK_MALFORMED_GRACE_MS ? "blocking" : "abandoned";
+  return ownerIsAbandoned(record5, metadata.mtimeMs) ? "abandoned" : "blocking";
 }
-async function tryAcquireLegacyCompatibilityGuard(legacyPath, record4) {
+async function tryAcquireLegacyCompatibilityGuard(legacyPath, record5) {
   const handle = await open9(legacyPath, "wx", 384).catch((error51) => {
     if (error51.code === "EEXIST") return null;
     throw error51;
@@ -43204,7 +44107,7 @@ async function tryAcquireLegacyCompatibilityGuard(legacyPath, record4) {
   const metadata = await handle.stat();
   const guard = { handle, identity: { dev: metadata.dev, ino: metadata.ino } };
   try {
-    await handle.writeFile(`${JSON.stringify(record4)}
+    await handle.writeFile(`${JSON.stringify(record5)}
 `, "utf8");
     await handle.sync();
     return guard;
@@ -43233,7 +44136,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const legacyPath = `${socketPath}.initializing`;
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
-  const ownerToken = randomUUID17();
+  const ownerToken = randomUUID18();
   const entryPath = path26.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
@@ -43270,8 +44173,8 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
         throw new Error(`Remote app-server socket lock ownership was lost at ${socketPath}`);
       }
       const blockedByBakery = catalog.entries.some((entry) => {
-        const record4 = entry.record;
-        return record4 !== null && record4.ownerToken !== ownerToken && (record4.choosing || recordHasPriority(record4, ownRecord));
+        const record5 = entry.record;
+        return record5 !== null && record5.ownerToken !== ownerToken && (record5.choosing || recordHasPriority(record5, ownRecord));
       });
       if (!catalog.unsettled && !blockedByBakery) {
         const legacyGuard = await tryAcquireLegacyCompatibilityGuard(legacyPath, {
@@ -43744,12 +44647,12 @@ function createRemoteAppServerWebSocketListener(input) {
 
 // packages/host-runtime/src/remote-official-app-server.ts
 import { spawn as spawn5 } from "node:child_process";
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 import { lstat as lstat7, rm as rm13, stat as stat7 } from "node:fs/promises";
 import path28 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
-function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID18()) {
+function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID19()) {
   if (!path28.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
@@ -44968,11 +45871,11 @@ async function readRemoteDelegationThread(environment, input) {
 }
 
 // packages/host-runtime/src/shared-thread-owner.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 import { PassThrough as PassThrough3 } from "node:stream";
 
 // packages/host-runtime/src/shared-thread-peer.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 function object5(value2) {
   return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
@@ -44986,7 +45889,7 @@ var StreamThreadPeer = class {
   input;
   output;
   stop;
-  #prefix = `shared:${randomUUID19()}:`;
+  #prefix = `shared:${randomUUID20()}:`;
   #pending = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #ended = Promise.withResolvers();
@@ -45064,7 +45967,7 @@ var SharedThreadOwner = class {
   input = new PassThrough3();
   output = new PassThrough3();
   #peer = new StreamThreadPeer(this.output, this.input, () => this.input.end());
-  #prefix = `shared-interaction:${randomUUID20()}:`;
+  #prefix = `shared-interaction:${randomUUID21()}:`;
   #interactions = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #receipts = /* @__PURE__ */ new Map();
@@ -45374,7 +46277,7 @@ var SharedThreadBridge = class {
 };
 
 // packages/host-runtime/src/remote-control-app-server.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 import { mkdir as mkdir15, open as open10, rename as rename12, rm as rm14 } from "node:fs/promises";
 import path33 from "node:path";
 var REMOTE_CONTROL_BRIDGE_PIPE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_PIPE";
@@ -45395,7 +46298,7 @@ function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\")) return value2.slice(4);
   return value2;
 }
-function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID21()) {
+function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID22()) {
   const safeInstance = instanceId.replaceAll(/[^a-zA-Z0-9-]/gu, "");
   if (!safeInstance) throw new Error("Remote Control bridge instance ID is invalid");
   return `\\\\.\\pipe\\codexhost-remote-control-${processId}-${safeInstance}`;
@@ -45410,7 +46313,7 @@ async function publishRemoteControlAppServerDescriptor(plan) {
   await mkdir15(directory, { recursive: true, mode: 448 });
   const temporaryPath = path33.join(
     directory,
-    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID21()}.tmp`
+    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID22()}.tmp`
   );
   const handle = await open10(temporaryPath, "wx", 384);
   try {
@@ -45603,12 +46506,12 @@ async function startConsoleControlServer(options2) {
         reply(response, 400, { error: { code: -32700, message: "Invalid request body" } });
         return;
       }
-      const record4 = typeof body === "object" && body !== null ? body : {};
-      if (typeof record4.method !== "string") {
+      const record5 = typeof body === "object" && body !== null ? body : {};
+      if (typeof record5.method !== "string") {
         reply(response, 400, { error: { code: -32600, message: "method is required" } });
         return;
       }
-      reply(response, 200, await options2.target.handleConsoleRequest(record4.method, record4.params));
+      reply(response, 200, await options2.target.handleConsoleRequest(record5.method, record5.params));
     })().catch((error51) => {
       if (!response.headersSent) {
         reply(response, 500, {
@@ -45903,7 +46806,7 @@ function createHostUpdateCoordinator(options2) {
                 onPrepared
               });
             }
-            if (platform !== "darwin") await manager.start(prepared2);
+            if (platform !== "darwin" && platform !== "win32") await manager.start(prepared2);
           } catch (error51) {
             await lock.release();
             rejectPrepared(error51);
@@ -45932,7 +46835,7 @@ function createHostUpdateCoordinator(options2) {
 }
 
 // packages/host-runtime/src/usage-statistics.ts
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 import { mkdir as mkdir17, readFile as readFile17, readdir as readdir6, rename as rename14, rm as rm16, writeFile as writeFile10 } from "node:fs/promises";
 import path36 from "node:path";
 import { setImmediate as yieldToEventLoop } from "node:timers/promises";
@@ -46027,14 +46930,14 @@ function parseHarnessUsageEntry(value2) {
 // packages/host-runtime/src/usage-session-titles.ts
 function withHostSessionTitles(result, records) {
   const titles = /* @__PURE__ */ new Map();
-  for (const record4 of records) {
-    const ref = record4.nativeSessionRef;
-    const title = usageSessionTitle(record4.title);
-    if (record4.state !== "ready" || !ref || ref.harnessId !== record4.harnessId || !title) continue;
-    const key = `${record4.harnessId}\0${ref.nativeSessionId}`;
+  for (const record5 of records) {
+    const ref = record5.nativeSessionRef;
+    const title = usageSessionTitle(record5.title);
+    if (record5.state !== "ready" || !ref || ref.harnessId !== record5.harnessId || !title) continue;
+    const key = `${record5.harnessId}\0${ref.nativeSessionId}`;
     const previous = titles.get(key);
-    if (!previous || record4.updatedAt > previous.updatedAt)
-      titles.set(key, { title, updatedAt: record4.updatedAt });
+    if (!previous || record5.updatedAt > previous.updatedAt)
+      titles.set(key, { title, updatedAt: record5.updatedAt });
   }
   const decorate = (sessions) => sessions.map((session) => {
     const title = titles.get(`${session.harness}\0${session.sessionId}`)?.title;
@@ -46205,6 +47108,8 @@ function emptyTotals() {
     cachedInputTokens: 0,
     cacheWriteInputTokens: 0,
     cacheKnownInputTokens: 0,
+    cacheHitCachedInputTokens: 0,
+    cacheHitInputTokens: 0,
     outputTokens: 0,
     reasoningOutputTokens: 0,
     costUsd: 0,
@@ -46221,6 +47126,10 @@ function addEntry(totals2, entry, cost) {
   totals2.inputTokens += entry.inputTokens;
   totals2.outputTokens += entry.outputTokens;
   totals2.reasoningOutputTokens += entry.reasoningOutputTokens ?? 0;
+  if (entry.cachedInputTokens !== void 0) {
+    totals2.cacheHitCachedInputTokens += entry.cachedInputTokens;
+    totals2.cacheHitInputTokens += entry.inputTokens;
+  }
   if (entry.cachedInputTokens !== void 0 && entry.cacheWriteInputTokens !== void 0) {
     totals2.cachedInputTokens += entry.cachedInputTokens;
     totals2.cacheWriteInputTokens += entry.cacheWriteInputTokens;
@@ -46467,7 +47376,7 @@ var UsageStatistics = class {
   async #persist(harness2, cache) {
     if (!cache.dirty || this.#now() - cache.persistedAtMs < PERSIST_INTERVAL_MS) return;
     const file2 = this.#file(harness2);
-    const temporary = `${file2}.${randomUUID22()}.tmp`;
+    const temporary = `${file2}.${randomUUID23()}.tmp`;
     try {
       await mkdir17(this.#directory, { recursive: true });
       const sources = [...cache.sources].map(([id2, source]) => [
@@ -47078,7 +47987,7 @@ async function runHostRuntime(input) {
 }
 
 // packages/host-runtime/src/remote-host-install.ts
-import { createHash as createHash11, randomUUID as randomUUID23 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID24 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import {
   access as access3,
@@ -47177,7 +48086,7 @@ async function writeAtomic(filePath, contents, mode) {
   await mkdir18(path38.dirname(filePath), { recursive: true, mode: 448 });
   const temporary = path38.join(
     path38.dirname(filePath),
-    `.${path38.basename(filePath)}.${process.pid}.${randomUUID23()}.tmp`
+    `.${path38.basename(filePath)}.${process.pid}.${randomUUID24()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -47201,7 +48110,7 @@ async function writeAtomicExecutable(filePath, sourcePath) {
   await mkdir18(path38.dirname(filePath), { recursive: true, mode: 448 });
   const temporary = path38.join(
     path38.dirname(filePath),
-    `.${path38.basename(filePath)}.${process.pid}.${randomUUID23()}.tmp`
+    `.${path38.basename(filePath)}.${process.pid}.${randomUUID24()}.tmp`
   );
   try {
     await copyFile4(sourcePath, temporary);
@@ -48209,7 +49118,7 @@ var harnessErrorSchema = external_exports.object({
 var harnessSessionStateSchema = external_exports.custom((value2) => {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2))
     return false;
-  const record4 = value2;
+  const record5 = value2;
   const allowed = /* @__PURE__ */ new Set([
     "nativeRef",
     "effectiveModel",
@@ -48218,12 +49127,12 @@ var harnessSessionStateSchema = external_exports.custom((value2) => {
     "availableThinkingOptions",
     "effectivePermissionModeId"
   ]);
-  if (Object.keys(record4).some((key) => !allowed.has(key)))
+  if (Object.keys(record5).some((key) => !allowed.has(key)))
     return false;
-  if (record4.nativeRef !== void 0 && !nativeSessionRefSchema.safeParse(record4.nativeRef).success) {
+  if (record5.nativeRef !== void 0 && !nativeSessionRefSchema.safeParse(record5.nativeRef).success) {
     return false;
   }
-  const { nativeRef: _nativeRef, ...configuration } = record4;
+  const { nativeRef: _nativeRef, ...configuration } = record5;
   void _nativeRef;
   return harnessConfigurationStateSchema.safeParse(configuration).success;
 });
@@ -48317,7 +49226,7 @@ function defaultHarnessBrokerSocketPath(environment = process.env, harnessId = "
 }
 
 // packages/harness-broker/dist/server.js
-import { randomBytes as randomBytes5, randomUUID as randomUUID24 } from "node:crypto";
+import { randomBytes as randomBytes5, randomUUID as randomUUID25 } from "node:crypto";
 import { chmod as chmod6, lstat as lstat10, mkdir as mkdir19, open as open11, readFile as readFile19, rename as rename16, rm as rm18 } from "node:fs/promises";
 import net4, {} from "node:net";
 import path41 from "node:path";
@@ -48376,7 +49285,7 @@ async function assertNoLiveDescriptor(descriptorPath) {
   }
 }
 async function publishDescriptor(descriptorPath, descriptor) {
-  const temporary = `${descriptorPath}.${process.pid}.${randomUUID24()}.tmp`;
+  const temporary = `${descriptorPath}.${process.pid}.${randomUUID25()}.tmp`;
   const handle = await open11(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(descriptor)}
@@ -48389,28 +49298,28 @@ async function publishDescriptor(descriptorPath, descriptor) {
   if (process.platform !== "win32")
     await chmod6(descriptorPath, 384);
 }
-function sessionMetadata(record4) {
-  const initialState = { ...record4.session.initialState };
-  if (record4.selection.model && initialState.effectiveModel?.id !== record4.selection.model.id) {
+function sessionMetadata(record5) {
+  const initialState = { ...record5.session.initialState };
+  if (record5.selection.model && initialState.effectiveModel?.id !== record5.selection.model.id) {
     delete initialState.resolvedModelLabel;
   }
-  if (record4.selection.thinkingOptionId && initialState.effectiveThinkingOptionId !== record4.selection.thinkingOptionId) {
+  if (record5.selection.thinkingOptionId && initialState.effectiveThinkingOptionId !== record5.selection.thinkingOptionId) {
     delete initialState.availableThinkingOptions;
   }
   return {
-    sessionId: record4.id,
-    sessionGeneration: record4.generation,
-    capabilities: record4.session.capabilities,
+    sessionId: record5.id,
+    sessionGeneration: record5.generation,
+    capabilities: record5.session.capabilities,
     readCapabilities: true,
     initialState: {
       ...initialState,
-      ...record4.nativeRef ? { nativeRef: record4.nativeRef } : {},
-      ...record4.selection.model ? { effectiveModel: record4.selection.model } : {},
-      ...record4.selection.thinkingOptionId ? { effectiveThinkingOptionId: record4.selection.thinkingOptionId } : {},
-      ...record4.selection.permissionModeId ? { effectivePermissionModeId: record4.selection.permissionModeId } : {}
+      ...record5.nativeRef ? { nativeRef: record5.nativeRef } : {},
+      ...record5.selection.model ? { effectiveModel: record5.selection.model } : {},
+      ...record5.selection.thinkingOptionId ? { effectiveThinkingOptionId: record5.selection.thinkingOptionId } : {},
+      ...record5.selection.permissionModeId ? { effectivePermissionModeId: record5.selection.permissionModeId } : {}
     },
-    initialUsage: record4.session.initialUsage,
-    commands: record4.session.commands !== void 0
+    initialUsage: record5.session.initialUsage,
+    commands: record5.session.commands !== void 0
   };
 }
 async function socketAcceptsConnections(socketPath) {
@@ -48454,7 +49363,7 @@ async function startHarnessBrokerServer(input) {
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);
-  const generation = input.generation ?? randomUUID24();
+  const generation = input.generation ?? randomUUID25();
   const token = input.token ?? randomBytes5(32).toString("hex");
   const descriptor = {
     schemaVersion: 1,
@@ -48495,7 +49404,7 @@ async function startHarnessBrokerServer(input) {
   };
   const server = net4.createServer((socket) => {
     const state = {
-      id: randomUUID24(),
+      id: randomUUID25(),
       socket,
       authenticated: false,
       inputSequence: 0,
@@ -48522,15 +49431,15 @@ async function startHarnessBrokerServer(input) {
     const respond2 = async (request, result) => {
       await send({ kind: "response", id: request.id, ...result });
     };
-    const releaseProvisionalWriter = (record4) => {
-      if (record4.provisionalWriterLease && provisionalNativeWriter === record4.id) {
+    const releaseProvisionalWriter = (record5) => {
+      if (record5.provisionalWriterLease && provisionalNativeWriter === record5.id) {
         provisionalNativeWriter = void 0;
       }
-      record4.provisionalWriterLease = false;
-      record4.awaitingNativeIdentity = false;
+      record5.provisionalWriterLease = false;
+      record5.awaitingNativeIdentity = false;
     };
-    const forwardOutputs = async (record4, nativeSession, sessionGeneration, forwarderEpoch) => {
-      const isCurrent = () => sessions.get(record4.id) === record4 && record4.session === nativeSession && record4.generation === sessionGeneration && record4.forwarderEpoch === forwarderEpoch;
+    const forwardOutputs = async (record5, nativeSession, sessionGeneration, forwarderEpoch) => {
+      const isCurrent = () => sessions.get(record5.id) === record5 && record5.session === nativeSession && record5.generation === sessionGeneration && record5.forwarderEpoch === forwarderEpoch;
       try {
         for await (const output of nativeSession.outputs) {
           if (!isCurrent())
@@ -48538,13 +49447,13 @@ async function startHarnessBrokerServer(input) {
           if (output.kind === "event" && output.event.type === "session.state.changed") {
             const state2 = output.event.state;
             const observedNativeId = state2.nativeRef?.nativeSessionId;
-            const expectedRef = record4.nativeWriterRef ?? record4.nativeRef;
+            const expectedRef = record5.nativeWriterRef ?? record5.nativeRef;
             if (state2.nativeRef && (state2.nativeRef.harnessId !== input.adapter.harnessId || expectedRef && (expectedRef.harnessId !== state2.nativeRef.harnessId || expectedRef.nativeSessionId !== state2.nativeRef.nativeSessionId || expectedRef.formatVersion !== state2.nativeRef.formatVersion))) {
-              record4.faulted = true;
-              releaseProvisionalWriter(record4);
+              record5.faulted = true;
+              releaseProvisionalWriter(record5);
               await send({
                 kind: "output",
-                sessionId: record4.id,
+                sessionId: record5.id,
                 sessionGeneration,
                 output: {
                   kind: "event",
@@ -48562,15 +49471,15 @@ async function startHarnessBrokerServer(input) {
               await nativeSession.close().catch(() => void 0);
               break;
             }
-            if (observedNativeId && !record4.writerKey) {
+            if (observedNativeId && !record5.writerKey) {
               const writerKey = nativeWriterKey(observedNativeId);
               const owner = nativeWriters.get(writerKey);
-              if (owner && owner !== record4.id) {
-                record4.faulted = true;
-                releaseProvisionalWriter(record4);
+              if (owner && owner !== record5.id) {
+                record5.faulted = true;
+                releaseProvisionalWriter(record5);
                 await send({
                   kind: "output",
-                  sessionId: record4.id,
+                  sessionId: record5.id,
                   sessionGeneration,
                   output: {
                     kind: "event",
@@ -48588,38 +49497,38 @@ async function startHarnessBrokerServer(input) {
                 await nativeSession.close().catch(() => void 0);
                 break;
               }
-              nativeWriters.set(writerKey, record4.id);
-              record4.nativeId = observedNativeId;
-              record4.nativeRef = state2.nativeRef;
-              record4.writerKey = writerKey;
-              releaseProvisionalWriter(record4);
+              nativeWriters.set(writerKey, record5.id);
+              record5.nativeId = observedNativeId;
+              record5.nativeRef = state2.nativeRef;
+              record5.writerKey = writerKey;
+              releaseProvisionalWriter(record5);
             }
             if (state2.nativeRef) {
-              record4.nativeId = state2.nativeRef.nativeSessionId;
-              record4.nativeRef = state2.nativeRef;
-              releaseProvisionalWriter(record4);
+              record5.nativeId = state2.nativeRef.nativeSessionId;
+              record5.nativeRef = state2.nativeRef;
+              releaseProvisionalWriter(record5);
             }
             if (state2.effectiveModel)
-              record4.selection.model = state2.effectiveModel;
+              record5.selection.model = state2.effectiveModel;
             if (state2.effectiveThinkingOptionId) {
-              record4.selection.thinkingOptionId = state2.effectiveThinkingOptionId;
+              record5.selection.thinkingOptionId = state2.effectiveThinkingOptionId;
             }
             if (state2.effectivePermissionModeId) {
-              record4.selection.permissionModeId = state2.effectivePermissionModeId;
+              record5.selection.permissionModeId = state2.effectivePermissionModeId;
             }
           }
           const authenticationTerminal = isAuthenticationTerminal(output);
           if (output.kind === "event" && output.event.type === "session.faulted") {
-            record4.faulted = true;
-            releaseProvisionalWriter(record4);
+            record5.faulted = true;
+            releaseProvisionalWriter(record5);
           }
           if (authenticationTerminal) {
-            record4.faulted = true;
-            releaseProvisionalWriter(record4);
+            record5.faulted = true;
+            releaseProvisionalWriter(record5);
           }
           await send({
             kind: "output",
-            sessionId: record4.id,
+            sessionId: record5.id,
             sessionGeneration,
             output
           });
@@ -48630,26 +49539,26 @@ async function startHarnessBrokerServer(input) {
         }
       } catch {
         if (isCurrent()) {
-          record4.faulted = true;
-          releaseProvisionalWriter(record4);
+          record5.faulted = true;
+          releaseProvisionalWriter(record5);
         }
       }
     };
-    const closeRecord = async (record4) => {
-      if (sessions.get(record4.id) !== record4)
+    const closeRecord = async (record5) => {
+      if (sessions.get(record5.id) !== record5)
         return;
-      sessions.delete(record4.id);
+      sessions.delete(record5.id);
       scheduleIdle();
-      state.sessions.delete(record4.id);
-      record4.forwarderEpoch += 1;
-      const nativeSession = record4.session;
-      const outputTask = record4.outputTask;
+      state.sessions.delete(record5.id);
+      record5.forwarderEpoch += 1;
+      const nativeSession = record5.session;
+      const outputTask = record5.outputTask;
       await nativeSession.close().catch(() => void 0);
       await outputTask.catch(() => void 0);
-      if (record4.writerKey && nativeWriters.get(record4.writerKey) === record4.id) {
-        nativeWriters.delete(record4.writerKey);
+      if (record5.writerKey && nativeWriters.get(record5.writerKey) === record5.id) {
+        nativeWriters.delete(record5.writerKey);
       }
-      releaseProvisionalWriter(record4);
+      releaseProvisionalWriter(record5);
     };
     const requireSession = (params) => {
       const candidate = params;
@@ -48657,13 +49566,13 @@ async function startHarnessBrokerServer(input) {
         sessionId: candidate.sessionId,
         sessionGeneration: candidate.sessionGeneration
       });
-      const record4 = sessions.get(parsed2.sessionId);
-      if (!record4 || record4.owner !== state.id)
+      const record5 = sessions.get(parsed2.sessionId);
+      if (!record5 || record5.owner !== state.id)
         throw new Error("Harness broker Session is unavailable");
-      if (record4.generation !== parsed2.sessionGeneration) {
+      if (record5.generation !== parsed2.sessionGeneration) {
         throw new Error("Harness broker Session generation is stale");
       }
-      return record4;
+      return record5;
     };
     const handleRequest = async (request) => {
       if (closed || state.closed)
@@ -48796,7 +49705,7 @@ async function startHarnessBrokerServer(input) {
             }
           };
         }
-        const openReservation = randomUUID24();
+        const openReservation = randomUUID25();
         if (sourceKey)
           nativeWriters.set(sourceKey, openReservation);
         const provisionalReservation = openInput.kind === "create" ? openReservation : void 0;
@@ -48876,7 +49785,7 @@ async function startHarnessBrokerServer(input) {
             };
           }
           const delayedCreateIdentity = openInput.kind === "create" && !nativeKey;
-          const record5 = {
+          const record6 = {
             id: openReservation,
             generation: 1,
             owner: state.id,
@@ -48897,18 +49806,18 @@ async function startHarnessBrokerServer(input) {
               ...opened.value.initialState.effectivePermissionModeId ? { permissionModeId: opened.value.initialState.effectivePermissionModeId } : {}
             }
           };
-          sessions.set(record5.id, record5);
-          state.sessions.add(record5.id);
+          sessions.set(record6.id, record6);
+          state.sessions.add(record6.id);
           if (nativeKey)
-            nativeWriters.set(nativeKey, record5.id);
-          if (sourceKey && sourceKey !== nativeKey && nativeWriters.get(sourceKey) === record5.id) {
+            nativeWriters.set(nativeKey, record6.id);
+          if (sourceKey && sourceKey !== nativeKey && nativeWriters.get(sourceKey) === record6.id) {
             nativeWriters.delete(sourceKey);
           }
-          if (!record5.provisionalWriterLease && provisionalNativeWriter === provisionalReservation) {
+          if (!record6.provisionalWriterLease && provisionalNativeWriter === provisionalReservation) {
             provisionalNativeWriter = void 0;
           }
-          record5.outputTask = forwardOutputs(record5, opened.value, record5.generation, record5.forwarderEpoch);
-          return { ok: true, value: sessionMetadata(record5) };
+          record6.outputTask = forwardOutputs(record6, opened.value, record6.generation, record6.forwarderEpoch);
+          return { ok: true, value: sessionMetadata(record6) };
         } finally {
           if (createSettled) {
             openingCreate = void 0;
@@ -48918,11 +49827,11 @@ async function startHarnessBrokerServer(input) {
       }
       if (request.method === "session.execute") {
         const parsed2 = sessionExecuteParamsSchema.parse(request.params);
-        const record5 = requireSession(parsed2);
+        const record6 = requireSession(parsed2);
         const command = brokerHostCommandSchema.parse(parsed2.command);
-        if (record5.awaitingNativeIdentity && !record5.writerKey) {
-          const isBootstrapTurn = command.type === "turn.start" && record5.provisionalWriterLease && record5.bootstrapTurnId === void 0;
-          const isBootstrapTurnContinuation = record5.bootstrapTurnId !== void 0 && (command.type === "turn.cancel" && command.turnId === record5.bootstrapTurnId || command.type === "interaction.respond");
+        if (record6.awaitingNativeIdentity && !record6.writerKey) {
+          const isBootstrapTurn = command.type === "turn.start" && record6.provisionalWriterLease && record6.bootstrapTurnId === void 0;
+          const isBootstrapTurnContinuation = record6.bootstrapTurnId !== void 0 && (command.type === "turn.cancel" && command.turnId === record6.bootstrapTurnId || command.type === "interaction.respond");
           if (!isBootstrapTurn && !isBootstrapTurnContinuation) {
             return {
               ok: false,
@@ -48935,17 +49844,17 @@ async function startHarnessBrokerServer(input) {
             };
           }
           if (command.type === "turn.start")
-            record5.bootstrapTurnId = command.turnId;
+            record6.bootstrapTurnId = command.turnId;
         }
         let result;
         if (command.type === "turn.start")
-          result = await record5.session.execute(command);
+          result = await record6.session.execute(command);
         else if (command.type === "turn.steer")
-          result = await record5.session.execute(command);
+          result = await record6.session.execute(command);
         else if (command.type === "turn.cancel")
-          result = await record5.session.execute(command);
+          result = await record6.session.execute(command);
         else if (command.type === "interaction.respond") {
-          result = await record5.session.execute({
+          result = await record6.session.execute({
             type: command.type,
             interactionId: command.interactionId,
             response: command.response.type === "question" ? {
@@ -48955,21 +49864,21 @@ async function startHarnessBrokerServer(input) {
             } : command.response
           });
         } else if (command.type === "model.select")
-          result = await record5.session.execute(command);
+          result = await record6.session.execute(command);
         else if (command.type === "thinking.select")
-          result = await record5.session.execute(command);
+          result = await record6.session.execute(command);
         else
-          result = await record5.session.execute(command);
-        if (!result.ok && command.type === "turn.start" && record5.awaitingNativeIdentity && record5.bootstrapTurnId === command.turnId) {
-          delete record5.bootstrapTurnId;
+          result = await record6.session.execute(command);
+        if (!result.ok && command.type === "turn.start" && record6.awaitingNativeIdentity && record6.bootstrapTurnId === command.turnId) {
+          delete record6.bootstrapTurnId;
         }
         if (result.ok) {
           if (command.type === "model.select")
-            record5.selection.model = command.model;
+            record6.selection.model = command.model;
           if (command.type === "thinking.select")
-            record5.selection.thinkingOptionId = command.thinkingOptionId;
+            record6.selection.thinkingOptionId = command.thinkingOptionId;
           if (command.type === "permissionMode.select")
-            record5.selection.permissionModeId = command.permissionModeId;
+            record6.selection.permissionModeId = command.permissionModeId;
         }
         return result;
       }
@@ -48981,10 +49890,10 @@ async function startHarnessBrokerServer(input) {
         return requireSession(request.params).session.readSnapshot();
       }
       if (request.method === "session.refreshUsage") {
-        const record5 = requireSession(request.params);
-        const refreshUsage = record5.session.refreshUsage;
+        const record6 = requireSession(request.params);
+        const refreshUsage = record6.session.refreshUsage;
         if (refreshUsage)
-          await refreshUsage.call(record5.session);
+          await refreshUsage.call(record6.session);
         return null;
       }
       if (request.method === "session.commands.list") {
@@ -49002,11 +49911,11 @@ async function startHarnessBrokerServer(input) {
         }) : { ok: false, error: harnessError("Commands unavailable", false) };
       }
       if (request.method === "session.reopen") {
-        const record5 = requireSession(request.params);
-        if (!record5.faulted) {
-          return { ok: true, value: sessionMetadata(record5) };
+        const record6 = requireSession(request.params);
+        if (!record6.faulted) {
+          return { ok: true, value: sessionMetadata(record6) };
         }
-        if (!record5.nativeRef) {
+        if (!record6.nativeRef) {
           return {
             ok: false,
             error: {
@@ -49017,17 +49926,17 @@ async function startHarnessBrokerServer(input) {
             }
           };
         }
-        const nativeRef = record5.nativeRef;
-        const oldSession = record5.session;
-        const oldOutputTask = record5.outputTask;
-        record5.forwarderEpoch += 1;
+        const nativeRef = record6.nativeRef;
+        const oldSession = record6.session;
+        const oldOutputTask = record6.outputTask;
+        record6.forwarderEpoch += 1;
         await oldSession.close().catch(() => void 0);
         await oldOutputTask.catch(() => void 0);
         const reopened = await input.adapter.open({
           kind: "resume",
-          cwd: record5.cwd,
+          cwd: record6.cwd,
           nativeRef,
-          ...record5.environment ? { environment: record5.environment } : {}
+          ...record6.environment ? { environment: record6.environment } : {}
         });
         if (!reopened.ok)
           return reopened;
@@ -49044,44 +49953,44 @@ async function startHarnessBrokerServer(input) {
             }
           };
         }
-        if (record5.selection.model && reopened.value.capabilities.configuration.selectModel) {
+        if (record6.selection.model && reopened.value.capabilities.configuration.selectModel) {
           const selected = await reopened.value.execute({
             type: "model.select",
-            model: record5.selection.model
+            model: record6.selection.model
           });
           if (!selected.ok) {
             await reopened.value.close().catch(() => void 0);
             return selected;
           }
         }
-        if (record5.selection.thinkingOptionId && reopened.value.capabilities.configuration.selectThinkingOption) {
+        if (record6.selection.thinkingOptionId && reopened.value.capabilities.configuration.selectThinkingOption) {
           const selected = await reopened.value.execute({
             type: "thinking.select",
-            thinkingOptionId: record5.selection.thinkingOptionId
+            thinkingOptionId: record6.selection.thinkingOptionId
           });
           if (!selected.ok) {
             await reopened.value.close().catch(() => void 0);
             return selected;
           }
         }
-        if (record5.selection.permissionModeId && reopened.value.capabilities.configuration.selectPermissionMode) {
+        if (record6.selection.permissionModeId && reopened.value.capabilities.configuration.selectPermissionMode) {
           const selected = await reopened.value.execute({
             type: "permissionMode.select",
-            permissionModeId: record5.selection.permissionModeId
+            permissionModeId: record6.selection.permissionModeId
           });
           if (!selected.ok) {
             await reopened.value.close().catch(() => void 0);
             return selected;
           }
         }
-        record5.session = reopened.value;
-        record5.generation += 1;
-        record5.faulted = false;
-        record5.outputTask = forwardOutputs(record5, reopened.value, record5.generation, record5.forwarderEpoch);
-        return { ok: true, value: sessionMetadata(record5) };
+        record6.session = reopened.value;
+        record6.generation += 1;
+        record6.faulted = false;
+        record6.outputTask = forwardOutputs(record6, reopened.value, record6.generation, record6.forwarderEpoch);
+        return { ok: true, value: sessionMetadata(record6) };
       }
-      const record4 = requireSession(request.params);
-      await closeRecord(record4);
+      const record5 = requireSession(request.params);
+      await closeRecord(record5);
       return null;
     };
     consumeBrokerFrames(socket, (raw) => {
@@ -49103,7 +50012,7 @@ async function startHarnessBrokerServer(input) {
           }
           state.authenticated = true;
           state.inputSequence = 1;
-          await send({ kind: "response", id: randomUUID24(), ok: true, value: { ready: true } });
+          await send({ kind: "response", id: randomUUID25(), ok: true, value: { ready: true } });
           return;
         }
         const parsed2 = harnessBrokerRequestSchema.safeParse(raw);
@@ -49143,9 +50052,9 @@ async function startHarnessBrokerServer(input) {
       state.closed = true;
       connections.delete(state);
       for (const sessionId of [...state.sessions]) {
-        const record4 = sessions.get(sessionId);
-        if (record4)
-          void closeRecord(record4);
+        const record5 = sessions.get(sessionId);
+        if (record5)
+          void closeRecord(record5);
       }
       scheduleIdle();
     });
@@ -49177,10 +50086,10 @@ async function startHarnessBrokerServer(input) {
       clearTimeout(idleTimer);
       for (const connection of connections)
         connection.socket.destroy();
-      for (const record4 of sessions.values())
-        record4.forwarderEpoch += 1;
-      await Promise.all([...sessions.values()].map((record4) => record4.session.close().catch(() => void 0)));
-      await Promise.all([...sessions.values()].map((record4) => record4.outputTask.catch(() => void 0)));
+      for (const record5 of sessions.values())
+        record5.forwarderEpoch += 1;
+      await Promise.all([...sessions.values()].map((record5) => record5.session.close().catch(() => void 0)));
+      await Promise.all([...sessions.values()].map((record5) => record5.outputTask.catch(() => void 0)));
       await input.adapter.close().catch(() => void 0);
       await new Promise((resolve) => server.close(() => resolve()));
       if (process.platform !== "win32")