lody 0.93.3 → 0.95.0

package/dist/chunks/{index-Bxge7nr7.js → index-qnlCmQGA.js}

@@ -4240,9 +4240,9 @@ function $constructor(name, initializer3, params) {
     inst._zod.traits.add(name);
     initializer3(inst, def);
     const proto = _.prototype;
-    const keys = Object.keys(proto);
-    for (let i = 0; i < keys.length; i++) {
-      const k = keys[i];
+    const keys2 = Object.keys(proto);
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
       if (!(k in inst)) {
         inst[k] = proto[k].bind(inst);
       }
@@ -4467,12 +4467,12 @@ function getElementAtPath(obj, path10) {
   return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
-  const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
+  const keys2 = Object.keys(promisesObj);
+  const promises = keys2.map((key) => promisesObj[key]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
-    for (let i = 0; i < keys.length; i++) {
-      resolvedObj[keys[i]] = results[i];
+    for (let i = 0; i < keys2.length; i++) {
+      resolvedObj[keys2[i]] = results[i];
     }
     return resolvedObj;
   });
@@ -6583,8 +6583,8 @@ function handlePropertyResult(result, final, key, input, isOptionalOut) {
   }
 }
 function normalizeDef(def) {
-  const keys = Object.keys(def.shape);
-  for (const k of keys) {
+  const keys2 = Object.keys(def.shape);
+  for (const k of keys2) {
     if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
       throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
     }
@@ -6592,9 +6592,9 @@ function normalizeDef(def) {
   const okeys = optionalKeys(def.shape);
   return {
     ...def,
-    keys,
-    keySet: new Set(keys),
-    numKeys: keys.length,
+    keys: keys2,
+    keySet: new Set(keys2),
+    numKeys: keys2.length,
     optionalKeys: new Set(okeys)
   };
 }
@@ -16411,11 +16411,11 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2);
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
-  const keys = new Set(Object.keys(def.entries));
+  const keys2 = new Set(Object.keys(def.entries));
   inst.extract = (values, params) => {
     const newEntries = {};
     for (const value of values) {
-      if (keys.has(value)) {
+      if (keys2.has(value)) {
         newEntries[value] = def.entries[value];
       } else
         throw new Error(`Key ${value} not found in enum`);
@@ -16430,7 +16430,7 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   inst.exclude = (values, params) => {
     const newEntries = { ...def.entries };
     for (const value of values) {
-      if (keys.has(value)) {
+      if (keys2.has(value)) {
         delete newEntries[value];
       } else
         throw new Error(`Key ${value} not found in enum`);
@@ -21253,6 +21253,68 @@ function toPromptUsage(tokenCount) {
     thoughtTokens: tokenCount.reasoningOutputTokens
   };
 }
+var keys = [
+  "inputTokens",
+  "outputTokens",
+  "cacheReadInputTokens",
+  "cacheCreationInputTokens",
+  "reasoningOutputTokens"
+];
+var empty = () => ({
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadInputTokens: 0,
+  cacheCreationInputTokens: 0,
+  reasoningOutputTokens: 0
+});
+function normalize(total) {
+  return {
+    inputTokens: Math.max(0, total.inputTokens - total.cachedInputTokens - total.cacheWriteInputTokens),
+    outputTokens: Math.max(0, total.outputTokens - total.reasoningOutputTokens),
+    cacheReadInputTokens: total.cachedInputTokens,
+    cacheCreationInputTokens: total.cacheWriteInputTokens,
+    reasoningOutputTokens: total.reasoningOutputTokens
+  };
+}
+var CodexTurnUsage = class {
+  previous;
+  turn;
+  requestedModel;
+  constructor(fresh = false, snapshot) {
+    this.previous = snapshot ? normalize(snapshot) : fresh ? empty() : void 0;
+  }
+  prepare(model) {
+    this.requestedModel = model;
+  }
+  start(turnId, model) {
+    if (this.turn?.id === turnId) return;
+    this.turn = { id: turnId, model: this.requestedModel ?? model, usage: empty() };
+  }
+  update(params) {
+    const next = normalize(params.tokenUsage.total);
+    const turn = this.turn;
+    if (!turn) {
+      this.previous = next;
+      return void 0;
+    }
+    if (params.turnId !== turn.id) return void 0;
+    if (!this.previous) {
+      this.previous = next;
+      return void 0;
+    }
+    const delta = empty();
+    for (const key of keys) delta[key] = Math.max(0, (next[key] ?? 0) - (this.previous[key] ?? 0));
+    this.previous = next;
+    if (!keys.some((key) => (delta[key] ?? 0) > 0)) return void 0;
+    for (const key of keys) turn.usage[key] = (turn.usage[key] ?? 0) + (delta[key] ?? 0);
+    return {
+      sessionId: params.threadId,
+      usage: { ...turn.usage, ...params.tokenUsage.modelContextWindow !== null && { contextWindow: params.tokenUsage.modelContextWindow } },
+      modelUsage: { [turn.model]: { ...turn.usage } },
+      _meta: { codex: { usageTurnId: turn.id } }
+    };
+  }
+};
 function hasOnlyWinLineEndings(string4) {
   return string4.includes("\r\n") && !string4.startsWith("\n") && !string4.match(/[^\r]\n/);
 }
@@ -23595,6 +23657,13 @@ var CodexEventHandler = class _CodexEventHandler {
       case "error":
         return await this.createErrorEvent(notification.params);
       case "turn/started":
+        if (notification.params.threadId === this.sessionState.sessionId) {
+          this.sessionState.turnUsage ??= new CodexTurnUsage();
+          this.sessionState.turnUsage.start(
+            notification.params.turn.id,
+            this.sessionState.currentModelId.replace(/\[.*?]$/, "")
+          );
+        }
         this.sessionState.currentTurnId = notification.params.turn.id;
         await this.flushPendingErrors();
         return null;
@@ -23733,34 +23802,16 @@ var CodexEventHandler = class _CodexEventHandler {
     }
   }
   async emitExtNotification(notification) {
-    switch (notification.method) {
-      case "thread/tokenUsage/updated":
-        await this.notifyExt(
-          ACP_EXT_SESSION_USAGE_UPDATE_METHOD,
-          this.createSessionUsageExtNotification(notification.params)
-        );
-        return;
-      default:
-        return;
+    if (notification.method === "thread/tokenUsage/updated" && notification.params.threadId === this.sessionState.sessionId) {
+      this.sessionState.turnUsage ??= new CodexTurnUsage();
+      const update = this.sessionState.turnUsage.update(notification.params);
+      if (update) await this.notifyExt(ACP_EXT_SESSION_USAGE_UPDATE_METHOD, update);
     }
   }
   async notifyExt(method, params) {
     const extMethod = method.startsWith("_") ? method : `_${method}`;
     await this.connection.notify(extMethod, params);
   }
-  createSessionUsageExtNotification(params) {
-    const totalUsage = params.tokenUsage.total;
-    return {
-      sessionId: this.sessionState.sessionId,
-      usage: {
-        inputTokens: totalUsage.inputTokens,
-        outputTokens: totalUsage.outputTokens,
-        cacheReadInputTokens: totalUsage.cachedInputTokens,
-        reasoningOutputTokens: totalUsage.reasoningOutputTokens,
-        ...params.tokenUsage.modelContextWindow === null ? {} : { contextWindow: params.tokenUsage.modelContextWindow }
-      }
-    };
-  }
   createSessionRateLimitsExtNotification(rateLimits) {
     return {
       rateLimits: [toLodyRateLimit(rateLimits)],
@@ -26651,7 +26702,7 @@ var package_default = {
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
     "@openai/codex": "^0.153.4",
-    "acp-extension-core": "0.1.4",
+    "acp-extension-core": "0.1.5",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
@@ -27710,8 +27761,8 @@ var CodexAcpClient = class {
       delivery: "inline"
     }, onTurnStarted);
   }
-  async runCompact(sessionId) {
-    await this.codexClient.runCompact({ threadId: sessionId });
+  async runCompact(sessionId, onTurnStarted) {
+    return await this.codexClient.runCompact({ threadId: sessionId }, onTurnStarted);
   }
   async getGoal(sessionId) {
     const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
@@ -28419,24 +28470,29 @@ var CodexAppServerClient = class {
   mcpServerStartupStates = /* @__PURE__ */ new Map();
   mcpServerStartupResolvers = [];
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
-  pendingCompactionCompletionResolvers = /* @__PURE__ */ new Map();
+  pendingCompactTurns = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
   turnRoutingCaptures = /* @__PURE__ */ new Map();
   threadStatusCaptures = /* @__PURE__ */ new Map();
   threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
   threadGoalClearedCaptures = /* @__PURE__ */ new Map();
   threadSettings = /* @__PURE__ */ new Map();
+  tokenUsage = /* @__PURE__ */ new Map();
   staleTurnIds = /* @__PURE__ */ new Map();
   turnCompletionTerminalError = null;
   constructor(connection) {
     this.connection = connection;
-    const failPendingTurns = () => this.rejectAllPendingTurnCompletions(
-      new Error("Codex process exited before completing the turn")
-    );
+    const failPendingTurns = () => {
+      const error48 = new Error("Codex process exited before completing the turn");
+      this.rejectAllPendingTurnCompletions(error48);
+    };
     this.connection.onClose(failPendingTurns);
     this.connection.onDispose(failPendingTurns);
     this.connection.onUnhandledNotification((data) => {
       const serverNotification = data;
+      if (serverNotification.method === "thread/tokenUsage/updated") {
+        this.tokenUsage.set(serverNotification.params.threadId, serverNotification.params);
+      }
       if (isMcpServerStatusUpdatedNotification(serverNotification)) {
         this.mcpServerStartupVersion += 1;
         this.mcpServerStartupStates.set(serverNotification.params.name, {
@@ -28448,10 +28504,18 @@ var CodexAppServerClient = class {
         this.resolveMcpServerStartupResolvers();
       }
       if (isTurnCompletedNotification(serverNotification)) {
+        const compact = this.pendingCompactTurns.get(serverNotification.params.threadId);
+        if (compact?.turnId === serverNotification.params.turn.id) {
+          compact.resolve(serverNotification.params);
+        }
         this.recordTurnCompleted(serverNotification.params);
       }
-      if (isCompactionCompletedNotification(serverNotification)) {
-        this.recordCompactionCompleted(serverNotification);
+      if (serverNotification.method === "turn/started") {
+        const compact = this.pendingCompactTurns.get(serverNotification.params.threadId);
+        if (compact && compact.turnId === null) {
+          compact.turnId = serverNotification.params.turn.id;
+          compact.onTurnStarted?.(compact.turnId);
+        }
       }
       if (isThreadStatusChangedNotification(serverNotification)) {
         this.recordThreadStatusChanged(serverNotification.params);
@@ -28536,6 +28600,7 @@ var CodexAppServerClient = class {
     this.elicitationHandlers.set(threadId, handler);
   }
   clearThreadHandlers(threadId) {
+    this.tokenUsage.delete(threadId);
     this.notificationHandlers.delete(threadId);
     this.approvalHandlers.delete(threadId);
     this.elicitationHandlers.delete(threadId);
@@ -28753,10 +28818,25 @@ var CodexAppServerClient = class {
       threadStatusChanged: handleThreadStatusChanged
     };
   }
-  async runCompact(params) {
-    const compactionCompleted = this.awaitCompactionCompleted(params.threadId);
-    await this.threadCompactStart(params);
-    return await compactionCompleted;
+  async runCompact(params, onTurnStarted) {
+    if (this.turnCompletionTerminalError) throw this.turnCompletionTerminalError;
+    if (this.pendingCompactTurns.has(params.threadId)) {
+      throw new Error("A compaction request already owns this thread");
+    }
+    const completion = new Promise((resolve, reject) => {
+      this.pendingCompactTurns.set(params.threadId, {
+        turnId: null,
+        onTurnStarted,
+        resolve,
+        reject
+      });
+    });
+    try {
+      const [, completed] = await Promise.all([this.threadCompactStart(params), completion]);
+      return completed;
+    } finally {
+      this.pendingCompactTurns.delete(params.threadId);
+    }
   }
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
@@ -28781,6 +28861,9 @@ var CodexAppServerClient = class {
   async threadProjectUpdate(params) {
     await this.sendRequest({ method: "thread/metadata/update", params });
   }
+  getThreadTokenUsage(threadId) {
+    return this.tokenUsage.get(threadId);
+  }
   async threadStart(params) {
     return await this.sendRequest({ method: "thread/start", params });
   }
@@ -28901,13 +28984,6 @@ var CodexAppServerClient = class {
       threadResolvers.set(turnId, { resolve, reject });
     });
   }
-  async awaitCompactionCompleted(threadId) {
-    return await new Promise((resolve) => {
-      const resolvers = this.pendingCompactionCompletionResolvers.get(threadId) ?? /* @__PURE__ */ new Set();
-      resolvers.add(resolve);
-      this.pendingCompactionCompletionResolvers.set(threadId, resolvers);
-    });
-  }
   resolveTurnInterrupted(threadId, turnId) {
     this.recordTurnCompleted({
       threadId,
@@ -28976,20 +29052,6 @@ var CodexAppServerClient = class {
       capture(event);
     }
   }
-  recordCompactionCompleted(event) {
-    const threadId = extractThreadId(event);
-    if (threadId === null) {
-      return;
-    }
-    const resolvers = this.pendingCompactionCompletionResolvers.get(threadId);
-    if (!resolvers) {
-      return;
-    }
-    this.pendingCompactionCompletionResolvers.delete(threadId);
-    for (const resolve of resolvers) {
-      resolve(event);
-    }
-  }
   recordThreadStatusChanged(event) {
     const captures = this.threadStatusCaptures.get(event.threadId);
     if (!captures) {
@@ -29074,6 +29136,8 @@ var CodexAppServerClient = class {
    */
   rejectAllPendingTurnCompletions(error48) {
     this.turnCompletionTerminalError ??= error48;
+    for (const compact of this.pendingCompactTurns.values()) compact.reject(error48);
+    this.pendingCompactTurns.clear();
     const threads = [...this.pendingTurnCompletionResolvers.values()];
     this.pendingTurnCompletionResolvers.clear();
     for (const threadResolvers of threads) {
@@ -29234,12 +29298,6 @@ function isThreadGoalUpdatedNotification(notification) {
 function isThreadGoalClearedNotification(notification) {
   return notification.method === "thread/goal/cleared";
 }
-function isCompactionCompletedNotification(notification) {
-  if (notification.method === "thread/compacted") {
-    return true;
-  }
-  return notification.method === "item/completed" && notification.params.item.type === "contextCompaction";
-}
 function goalsMatch(left, right) {
   return left.threadId === right.threadId && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget && left.updatedAt === right.updatedAt;
 }
@@ -29504,8 +29562,18 @@ var CodexCommands = class {
         return { handled: options.setConfigOption !== void 0 };
       }
       case "compact": {
-        await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
-        return { handled: true };
+        options.onTurnStartPending?.();
+        options.onCompactionStarted?.();
+        try {
+          const turnCompleted = await this.runWithProcessCheck(
+            () => this.codexAcpClient.runCompact(sessionId, (turnId) => {
+              options.onTurnStarted?.(turnId, sessionId);
+            })
+          );
+          return { handled: true, turnCompleted };
+        } finally {
+          options.onCompactionFinished?.();
+        }
       }
       case "goal": {
         return await this.runGoalCommand(sessionState, command.rest, options);
@@ -31852,6 +31920,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.cwd,
       () => sessionState.sessionTitleSource
     );
+    if (operation.kind === "new") sessionState.turnUsage = new CodexTurnUsage(true);
     this.installSessionState(sessionState);
     this.publishRateLimitsAsync(sessionState);
     subscribed = false;
@@ -32599,7 +32668,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         throw error48;
       }
       logger.error(`Steering request for session ${params.sessionId} failed`, error48);
-      return { outcome: "failed" };
+      throw error48;
     } finally {
       if (queue.isIdle && this.steeringQueues.get(params.sessionId) === queue) {
         this.steeringQueues.delete(params.sessionId);
@@ -32636,7 +32705,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     this.assertSteerInputSupported(params, sessionState);
     const turnId = await this.getSteerableTurnId(sessionState);
     if (turnId) {
-      const injected = await this.injectSteerIntoActiveTurn(params, turnId, sessionState);
+      const injected = await this.injectSteerIntoActiveTurn(params, turnId);
       if (injected) {
         logger.log("Steering session injected", { sessionId: params.sessionId, turnId });
         return { outcome: "injected" };
@@ -32657,15 +32726,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
   /**
    * Attempts to inject the prompt into the given running turn.
    *
-   * A failed injection is fatal only when the turn is still the session's
-   * current turn and Codex reported something other than "no active turn to
-   * steer". Otherwise the turn has already ended underneath us and steering
-   * reports a failed delivery.
-   *
-   * @returns true when the prompt was injected; false when the target turn
-   *     already ended.
+   * After submission, only an explicit refusal proves non-delivery. A turn
+   * ending (including Stop) does not prove whether it consumed the input.
    */
-  async injectSteerIntoActiveTurn(params, turnId, sessionState) {
+  async injectSteerIntoActiveTurn(params, turnId) {
     const activePrompt = this.activePrompts.get(params.sessionId);
     const activeTurn = activePrompt?.currentTurn;
     const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
@@ -32679,8 +32743,23 @@ Check ${configPath} and project .codex directories, especially their config.toml
     if (pending.has(params.steerId)) {
       throw RequestError.invalidRequest(`Duplicate Codex steer id: ${params.steerId}`);
     }
-    pending.set(params.steerId, { activePrompt, turnId });
+    let resolveApplied = () => {
+    };
+    const applied = new Promise((resolve) => {
+      resolveApplied = resolve;
+    });
+    const steer = {
+      activePrompt,
+      threadId: activeTurn.threadId,
+      turnId,
+      requestPending: true,
+      acknowledgement: null,
+      applied,
+      resolveApplied
+    };
+    pending.set(params.steerId, steer);
     this.pendingSteers.set(params.sessionId, pending);
+    let requestAccepted = false;
     try {
       const response = await this.runWithProcessCheck(() => this.codexAcpClient.steerTurn({
         threadId: activeTurn.threadId,
@@ -32694,18 +32773,48 @@ Check ${configPath} and project .codex directories, especially their config.toml
           `Codex steered unexpected turn ${response.turnId}; expected ${turnId}`
         );
       }
+      requestAccepted = true;
       return true;
     } catch (err) {
-      if (pending.get(params.steerId)?.activePrompt === activePrompt) {
-        pending.delete(params.steerId);
-        if (pending.size === 0) this.pendingSteers.delete(params.sessionId);
+      const refused = this.isNoActiveTurnToSteerError(err);
+      if (await this.reconcileSteer(params, steer, !refused)) {
+        await this.acknowledgeSteer(params.sessionId, params.steerId, steer);
+        return true;
       }
-      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
-      const turnStillActive = sessionState.currentTurnId === turnId;
-      if (turnStillActive && !this.isNoActiveTurnToSteerError(err)) {
-        throw err;
+      if (refused) return false;
+      throw err;
+    } finally {
+      steer.requestPending = false;
+      if (!requestAccepted || this.activePrompts.get(params.sessionId) !== activePrompt) {
+        this.removePendingSteer(params.sessionId, params.steerId, steer);
       }
-      return false;
+    }
+  }
+  async reconcileSteer(params, steer, readHistory) {
+    let finished = false;
+    let timeout;
+    try {
+      const historyApplied = (async () => {
+        await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+        if (steer.acknowledgement !== null) return true;
+        if (finished || !readHistory) return false;
+        const thread = await this.codexAcpClient.readSessionHistory(steer.threadId);
+        return thread.id === steer.threadId && thread.turns.some((turn) => turn.id === steer.turnId && turn.items.some((item) => item.type === "userMessage" && item.clientId === params.steerId));
+      })().catch((error48) => {
+        logger.error("Could not reconcile Codex steer history", error48);
+        return false;
+      });
+      return await Promise.race([
+        historyApplied,
+        steer.applied.then(() => true),
+        new Promise((resolve) => {
+          timeout = setTimeout(() => resolve(false), 5e3);
+          timeout.unref?.();
+        })
+      ]) || steer.acknowledgement !== null;
+    } finally {
+      finished = true;
+      clearTimeout(timeout);
     }
   }
   async startGoalContinuationIfCurrent(sessionState, sessionGeneration, goalControlGeneration, expectedGoal) {
@@ -33515,6 +33624,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       signal: abortController.signal,
       currentTurn: null,
       hasCompletedTurn: false,
+      compactionInFlight: false,
       requestCancel: () => {
         if (abortController.signal.aborted) {
           return;
@@ -33549,7 +33659,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const pending = this.pendingSteers.get(sessionId);
     if (!pending) return;
     for (const [steerId, steer] of pending) {
-      if (steer.activePrompt === activePrompt) pending.delete(steerId);
+      if (steer.activePrompt === activePrompt && !steer.requestPending) pending.delete(steerId);
     }
     if (pending.size === 0) this.pendingSteers.delete(sessionId);
   }
@@ -33560,14 +33670,26 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const pending = this.pendingSteers.get(sessionId);
     if (!pending) return;
     const steer = pending.get(steerId);
-    if (!steer || steer.activePrompt !== activePrompt || steer.turnId !== event.params.turnId) return;
+    if (!steer || steer.activePrompt !== activePrompt || steer.threadId !== event.params.threadId || steer.turnId !== event.params.turnId) return;
+    await this.acknowledgeSteer(sessionId, steerId, steer);
+  }
+  removePendingSteer(sessionId, steerId, steer) {
+    const pending = this.pendingSteers.get(sessionId);
+    if (pending?.get(steerId) !== steer) return;
     pending.delete(steerId);
     if (pending.size === 0) this.pendingSteers.delete(sessionId);
-    await this.connection.notify(CODEX_STEER_APPLIED_METHOD, { sessionId, steerId });
+  }
+  async acknowledgeSteer(sessionId, steerId, steer) {
+    if (steer.acknowledgement === null) {
+      steer.acknowledgement = Promise.resolve().then(() => this.connection.notify(CODEX_STEER_APPLIED_METHOD, { sessionId, steerId }));
+      this.removePendingSteer(sessionId, steerId, steer);
+      steer.resolveApplied();
+    }
+    await steer.acknowledgement;
   }
   cancelBeforeTurnStarted(activePrompt) {
     return activePrompt.cancelSignal.then(() => {
-      if (activePrompt.currentTurn === null) {
+      if (activePrompt.currentTurn === null && !activePrompt.compactionInFlight) {
         return null;
       }
       return new Promise(() => {
@@ -33635,7 +33757,12 @@ Check ${configPath} and project .codex directories, especially their config.toml
       logger.error(`${requestName} - turnInterrupt failed`, err);
     }
   }
-  interruptLateStartedTurn(turn) {
+  interruptLateStartedTurn(turn, activePrompt) {
+    if (activePrompt.compactionInFlight) {
+      this.codexAcpClient.markTurnStale(turn);
+      void this.requestTurnInterrupt(turn, "Cancel");
+      return;
+    }
     void this.interruptPromptTurn(turn, "Close");
   }
   promptShouldStop(sessionId, activePrompt) {
@@ -33747,6 +33874,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return this.cancelledPromptResponse(sessionState);
     };
     try {
+      sessionState.turnUsage ??= new CodexTurnUsage(
+        false,
+        this.codexAcpClient.appServerClient.getThreadTokenUsage(params.sessionId)?.tokenUsage.total
+      );
+      sessionState.turnUsage.prepare(ModelId.fromString(sessionState.currentModelId).model);
       const promptEventHandler = new CodexEventHandler(
         this.connection,
         sessionState,
@@ -33783,7 +33915,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               const turn = { threadId: params.sessionId, turnId: event.params.turn.id };
               activePrompt.currentTurn = turn;
               if (this.promptShouldStop(params.sessionId, activePrompt)) {
-                this.interruptLateStartedTurn(turn);
+                this.interruptLateStartedTurn(turn, activePrompt);
                 return;
               }
               recoverableSessionFailure = sessionState.sessionFailure;
@@ -33825,13 +33957,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
           if (threadId === params.sessionId) goalLifecycle.startTurn(turnId);
           activePrompt.currentTurn = turn;
           if (this.promptShouldStop(params.sessionId, activePrompt)) {
-            this.interruptLateStartedTurn(turn);
+            this.interruptLateStartedTurn(turn, activePrompt);
             return;
           }
           sessionState.currentTurnId = turnId;
           pendingTurnStart?.resolve(turnId);
           onTurnStarted?.();
         },
+        onCompactionStarted: () => {
+          activePrompt.compactionInFlight = true;
+        },
+        onCompactionFinished: () => {
+          activePrompt.compactionInFlight = false;
+        },
         setConfigOption: async (configId, value) => {
           await this.applySessionConfigOption(sessionState, {
             sessionId: sessionState.sessionId,
@@ -33929,6 +34067,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.lastTokenUsage = null;
       ensurePendingTurnStart();
       goalLifecycle.prepareTurn();
+      sessionState.turnUsage.prepare(modelId.model);
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           effectiveParams,
@@ -33947,7 +34086,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             }
             activePrompt.currentTurn = turn;
             if (this.promptShouldStop(params.sessionId, activePrompt)) {
-              this.interruptLateStartedTurn(turn);
+              this.interruptLateStartedTurn(turn, activePrompt);
               return;
             }
             sessionState.currentTurnId = turnId;
@@ -34031,6 +34170,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           activePrompt.currentTurn = null;
           sessionState.currentTurnId = null;
           goalLifecycle.prepareTurn();
+          sessionState.turnUsage.prepare(modelId.model);
           const implementationPromise = this.runWithProcessCheck(
             () => this.codexAcpClient.sendPrompt(
               implementationRequest,
@@ -34045,7 +34185,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
                 if (!goalLifecycle.startSubmittedTurn(turnId)) return;
                 activePrompt.currentTurn = turn;
                 if (this.promptShouldStop(params.sessionId, activePrompt)) {
-                  this.interruptLateStartedTurn(turn);
+                  this.interruptLateStartedTurn(turn, activePrompt);
                   return;
                 }
                 sessionState.currentTurnId = turnId;
@@ -34287,6 +34427,10 @@ ${stderr}` : "";
       return;
     }
     const activePrompt = this.activePrompts.get(params.sessionId);
+    if (activePrompt?.compactionInFlight) {
+      activePrompt.requestCancel();
+      if (activePrompt.currentTurn === null) return;
+    }
     if (activePrompt?.hasCompletedTurn && activePrompt.currentTurn === null) {
       activePrompt.requestCancel();
       return;