@codexhost/cli-linux-arm64 0.15.0 → 0.16.0

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. */
@@ -22494,8 +22497,110 @@ function retainRendererHostResponses(client, hostId2, target) {
   };
 }
 
+// packages/desktop-control/dist/renderer-prewarm-consumption.js
+function isolateRendererPrewarmConsumption(manager, discardExternal) {
+  const record4 = (value2) => value2 !== null && typeof value2 === "object";
+  if (!record4(manager) || !record4(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" || !record4(params))
+    return null;
+  const prototype = Object.getPrototypeOf(creation);
+  if (!record4(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 (!record4(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 = record4(options2) ? options2.clientThreadId : null;
+    const mode = record4(input) && record4(input.collaborationMode) ? input.collaborationMode : null;
+    const origin = mode ? Reflect.get(mode, draftIdentity) : void 0;
+    if (mode && record4(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 (!record4(input) || !record4(input.collaborationMode) || !record4(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 = record4(input) && record4(input.collaborationMode) ? input.collaborationMode : null;
+    const expected = mode && record4(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 (!record4(warmed) || !record4(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 (record4(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 +22990,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 +23011,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 +23040,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 +23099,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 +23108,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 +23137,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) {
@@ -23299,12 +23397,14 @@ function directRendererInstaller() {
     const resolveRendererHostManager = ${resolveRendererHostManager.toString()};
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
+    const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
     const routing = (${installRendererHostRouting.toString()})(
       document, window,
       (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
       (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
       (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
+        isolateRendererPrewarmConsumption,
       ),
     );
     // Publish a default draft policy only when its Host is unambiguous. Host
@@ -26523,13 +26623,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();
   }
@@ -32693,6 +32797,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();
@@ -38638,16 +38755,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 +38945,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
         );
       }
@@ -41688,29 +41796,23 @@ 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);
+    await this.#writer.json(rpcEnvelope(request, { result: {} }));
+    await this.#writer.json({
+      method: "thread/deleted",
+      params: { threadId: location.record.hostThreadId }
+    });
   }
   async #readExternalThreadMetadata(request, location) {
     try {
@@ -42341,7 +42443,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 +42491,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) {
@@ -42651,7 +42753,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 +42804,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 +42876,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) {
@@ -42826,7 +42939,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 +42957,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 +42984,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 +42996,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;
@@ -45903,7 +46018,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);
@@ -46205,6 +46320,8 @@ function emptyTotals() {
     cachedInputTokens: 0,
     cacheWriteInputTokens: 0,
     cacheKnownInputTokens: 0,
+    cacheHitCachedInputTokens: 0,
+    cacheHitInputTokens: 0,
     outputTokens: 0,
     reasoningOutputTokens: 0,
     costUsd: 0,
@@ -46221,6 +46338,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;

package/app/plugins/antigravity/plugin.mjs

@@ -15089,6 +15089,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. */

package/app/plugins/claude-code/plugin.mjs

@@ -14683,6 +14683,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. */
@@ -57290,11 +57292,11 @@ var ClaudeSdkTransport = class {
       this.#slashCommands = parseClaudeSlashCommands(message.commands);
     }
   }
-  async getContextUsage() {
+  async getContextUsage(detail = "full") {
     const activeQuery = this.#query;
     if (!this.#started || !activeQuery)
       return null;
-    return parseContextUsage(await activeQuery.getContextUsage());
+    return parseContextUsage(await activeQuery.getContextUsage({ detail }));
   }
   getPermissionMode() {
     if (!this.#started || !this.#query)
@@ -59153,7 +59155,6 @@ var ClaudeHarnessSession = class {
   #lastAssistantResponseAtUnix;
   #accountCreditsSupported;
   #minimumContextUsedTokens = null;
-  #latestRequestModel = null;
   #calibratedInputTokens = 0;
   #calibratedOutputTokens = 0;
   #calibratedCostUsd = 0;
@@ -59660,15 +59661,16 @@ var ClaudeHarnessSession = class {
       };
     }
   }
-  refreshUsage() {
+  async refreshUsage() {
+    await this.#contextRefreshInFlight;
     if (this.#phase !== "open" || !this.#transport)
-      return Promise.resolve();
+      return;
     const now = Date.now();
     if (now < this.#contextUsageFreshUntilMs || now < this.#contextUsageCooldownUntilMs) {
-      return Promise.resolve();
+      return;
     }
     this.#requestContextUsage(this.#transport, this.#active?.command.turnId, CONTEXT_USAGE_RETRY_DELAYS_MS);
-    return this.#contextRefreshInFlight ?? Promise.resolve();
+    await this.#contextRefreshInFlight;
   }
   blocksRollback(sessionId) {
     return this.#sessionId === sessionId && (this.#phase !== "open" || this.#active !== null || this.#acceptingTurn || this.#configurationTask !== null || this.#readingHistory);
@@ -60802,7 +60804,7 @@ var ClaudeHarnessSession = class {
       this.#finishFailed(active, transportFailure(result.kind));
     }
   }
-  #requestContextUsage(transport, turnId, retryDelaysMs) {
+  #requestContextUsage(transport, turnId, retryDelaysMs, detail = "full") {
     if (this.#phase !== "open" || this.#transport !== transport)
       return;
     if (this.#contextRefreshInFlight)
@@ -60811,7 +60813,8 @@ var ClaudeHarnessSession = class {
       transport,
       ...turnId !== void 0 ? { turnId } : {},
       generation: this.#usageGeneration,
-      retryDelaysMs
+      retryDelaysMs,
+      detail
     };
     this.#contextRefreshInFlight = this.#drainContextUsage();
   }
@@ -60837,14 +60840,16 @@ var ClaudeHarnessSession = class {
         return;
       }
       try {
-        const context = await request.transport.getContextUsage();
+        const context = await request.transport.getContextUsage(request.detail);
         if (this.#phase !== "open" || this.#transport !== request.transport || this.#usageGeneration !== request.generation || this.#contextRefreshPending !== null) {
           return;
         }
         if (context === null)
           continue;
-        this.#contextUsageFreshUntilMs = Date.now() + CONTEXT_USAGE_TTL_MS;
-        this.#contextUsageCooldownUntilMs = 0;
+        if (request.detail === "full") {
+          this.#contextUsageFreshUntilMs = Date.now() + CONTEXT_USAGE_TTL_MS;
+          this.#contextUsageCooldownUntilMs = 0;
+        }
         this.#mergeAndPublishUsage({
           contextUsedTokens: Math.max(context.usedTokens, this.#minimumContextUsedTokens ?? 0),
           contextWindowTokens: context.maxTokens
@@ -60853,7 +60858,7 @@ var ClaudeHarnessSession = class {
       } catch {
       }
     }
-    if (this.#phase === "open" && this.#transport === request.transport && this.#usageGeneration === request.generation) {
+    if (request.detail === "full" && this.#phase === "open" && this.#transport === request.transport && this.#usageGeneration === request.generation) {
       this.#contextUsageCooldownUntilMs = Date.now() + CONTEXT_USAGE_FAILURE_COOLDOWN_MS;
     }
   }
@@ -60919,8 +60924,6 @@ var ClaudeHarnessSession = class {
     const promptTokens = usage.inputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
     if (promptTokens > 0)
       this.#minimumContextUsedTokens = promptTokens;
-    if (usage.model)
-      this.#latestRequestModel = usage.model;
     const cacheHitRatePercent = claudeCacheHitRatePercent(usage);
     const contextWindowTokens = this.#latestUsage?.contextWindowTokens;
     this.#mergeAndPublishUsage({
@@ -60962,24 +60965,11 @@ var ClaudeHarnessSession = class {
       if (cacheHitRatePercent !== void 0)
         delta.cacheHitRatePercent = cacheHitRatePercent;
     }
-    if (this.#latestUsage?.contextWindowTokens === void 0 && this.#minimumContextUsedTokens !== null) {
-      const contextWindowTokens = this.#resultContextWindow(event.modelUsage);
-      if (contextWindowTokens !== void 0) {
-        delta.contextUsedTokens = this.#minimumContextUsedTokens;
-        delta.contextWindowTokens = contextWindowTokens;
-      }
+    if (this.#transport && this.#minimumContextUsedTokens !== null && event.modelUsage?.some(({ contextWindowTokens }) => contextWindowTokens !== void 0)) {
+      this.#requestContextUsage(this.#transport, active.command.turnId, [0], "summary");
     }
     this.#mergeAndPublishUsage(delta, active.command.turnId);
   }
-  /** The latest request's Model, else the Model that carried the most prompt tokens. */
-  #resultContextWindow(modelUsage) {
-    if (!modelUsage?.length)
-      return void 0;
-    const latest = this.#latestRequestModel;
-    const matched = latest ? modelUsage.find(({ model: model2 }) => model2 === latest) : void 0;
-    const main = matched ?? modelUsage.reduce((best, entry) => (entry.promptTokens ?? entry.inputTokens) > (best.promptTokens ?? best.inputTokens) ? entry : best);
-    return main.contextWindowTokens;
-  }
   /**
    * Plan usage is account-wide, not Thread-scoped, so every observation is
    * offered to the Adapter's shared cache regardless of this Session's own