pi-openai-codex-compat 0.0.7 → 0.0.9

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 0.0.9 - 2026-08-16
+
+### Fixed
+
+- Preserve deferred incomplete and failed Codex response handling across linked tool execution without requiring session affinity or Pi agent-turn hooks.
+- Preserve provider items committed before a later context-overflow subrequest, compact the validated prefix, and retry automatically from the native checkpoint.
+- Split successful Codex follow-up sampling at percentage-compaction boundaries so Pi records the committed prefix, native checkpoint, and continued response in chronological order without synthetic model input.
+
+## 0.0.8 - 2026-08-16
+
+### Fixed
+
+- Match Codex tool-call commit semantics by trusting only `response.output_item.done`, ignoring terminal output snapshots and terminal-only calls, executing the completed subset of mixed batches, and preserving completed calls across incomplete or failed response handling.
+
 ## 0.0.7 - 2026-08-16
 
 ### Added

package/README.md

@@ -35,19 +35,19 @@ The compatibility baseline is official Codex CLI `0.146.0`, released July 29, 20
 
 ### Configurable defaults that differ from Codex
 
-| Area                                          | This package by default                                                                                                                           | Official Codex                                                                                                                                | Configuration                                                                              |
-| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
-| Generated-image detail sent back to the model | Sends image tool-result content with `input_image.detail: "auto"`. On GPT-5.6, `auto` uses original-size image accounting.                        | Uses `high`.                                                                                                                                  | `imageDetail`: `auto`, `low`, `high`, or `original`.                                       |
-| Image-generation tool                         | Enabled whenever an `openai-codex` model is selected. Backend capability and account failures surface when the tool executes.                     | Stable and enabled by default, but additionally gated by plan, model, provider, authentication, image-generation, and namespace capabilities. | `imageGeneration`: boolean.                                                                |
-| Standalone `web.run`                          | Disabled by default; when enabled, preferred over hosted `web_search` and sent with the complete reserved schema and description.                 | Enabled by default for `gpt-5.6-sol` through Responses Lite; otherwise subject to standalone-search feature and runtime gates.                | `webRun`: boolean.                                                                         |
-| Hosted web search                             | Disabled by default; when enabled, injected only for ordinary Responses while `web.run` is inactive. Responses Lite omits hosted tools.           | Omitted for `gpt-5.6-sol` while standalone `web.run` is available; otherwise defaults to cached mode when hosted search is supported.         | `webRun` and `webSearch`: `disabled`, `cached`, `indexed`, or `live`.                      |
-| Coding mutation tools                         | Enables `apply_patch` and suppresses Pi's active `edit` and `write` tools.                                                                        | Chooses its tool surface from model metadata and runtime capabilities; there are no Pi `edit` or `write` tools to suppress.                   | `applyPatch`: boolean.                                                                     |
-| `apply_patch` debug output                    | Disabled; collapsed results show the normal visual summary and instruction rows.                                                                  | Not applicable to Pi's tool-result renderer.                                                                                                  | `applyPatchDebug`: boolean.                                                                |
-| Codex tool background                         | Uses a subtle theme-derived surface for extension-owned Codex tools.                                                                              | Uses Codex's own TUI activity cells rather than Pi tool rows.                                                                                 | `toolBackground`: `subtle`, `status`, or `none`.                                           |
-| Auto-compaction trigger                       | Relies on Pi's reserve-token threshold unless a percentage is configured.                                                                         | Tracks Codex's model/token-budget state before and between sampling steps.                                                                    | `autoCompactAtPercent`: percentage or unset. Pi's own compaction settings remain separate. |
-| Fast mode                                     | Uses the normal tier.                                                                                                                             | Uses the configured Codex service tier.                                                                                                       | `fastMode`: boolean; `true` requests the priority tier.                                    |
-| Responses Lite                                | Disabled; supported GPT-5.6 models use ordinary Responses.                                                                                        | Enabled according to Codex model metadata.                                                                                                    | `responsesLite`: boolean; `true` enables Responses Lite.                                   |
-| Text and reasoning request controls           | Sends low text verbosity and automatic reasoning summaries; omits the default GPT-5.6 standard mode and sends `reasoning.mode` only for pro mode. | Resolves these controls through Codex configuration, model metadata, and turn state.                                                          | `textVerbosity`, `reasoningSummary`, and `reasoningMode`.                                  |
+| Area                                          | This package by default                                                                                                                           | Official Codex                                                                                                                                | Configuration                                                                                                                                                               |
+| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Generated-image detail sent back to the model | Sends image tool-result content with `input_image.detail: "auto"`. On GPT-5.6, `auto` uses original-size image accounting.                        | Uses `high`.                                                                                                                                  | `imageDetail`: `auto`, `low`, `high`, or `original`.                                                                                                                        |
+| Image-generation tool                         | Enabled whenever an `openai-codex` model is selected. Backend capability and account failures surface when the tool executes.                     | Stable and enabled by default, but additionally gated by plan, model, provider, authentication, image-generation, and namespace capabilities. | `imageGeneration`: boolean.                                                                                                                                                 |
+| Standalone `web.run`                          | Disabled by default; when enabled, preferred over hosted `web_search` and sent with the complete reserved schema and description.                 | Enabled by default for `gpt-5.6-sol` through Responses Lite; otherwise subject to standalone-search feature and runtime gates.                | `webRun`: boolean.                                                                                                                                                          |
+| Hosted web search                             | Disabled by default; when enabled, injected only for ordinary Responses while `web.run` is inactive. Responses Lite omits hosted tools.           | Omitted for `gpt-5.6-sol` while standalone `web.run` is available; otherwise defaults to cached mode when hosted search is supported.         | `webRun` and `webSearch`: `disabled`, `cached`, `indexed`, or `live`.                                                                                                       |
+| Coding mutation tools                         | Enables `apply_patch` and suppresses Pi's active `edit` and `write` tools.                                                                        | Chooses its tool surface from model metadata and runtime capabilities; there are no Pi `edit` or `write` tools to suppress.                   | `applyPatch`: boolean.                                                                                                                                                      |
+| `apply_patch` debug output                    | Disabled; collapsed results show the normal visual summary and instruction rows.                                                                  | Not applicable to Pi's tool-result renderer.                                                                                                  | `applyPatchDebug`: boolean.                                                                                                                                                 |
+| Codex tool background                         | Uses a subtle theme-derived surface for extension-owned Codex tools.                                                                              | Uses Codex's own TUI activity cells rather than Pi tool rows.                                                                                 | `toolBackground`: `subtle`, `status`, or `none`.                                                                                                                            |
+| Auto-compaction trigger                       | Relies on Pi's reserve-token threshold unless a percentage is configured.                                                                         | Tracks Codex's model/token-budget state before and between sampling steps.                                                                    | `autoCompactAtPercent`: percentage or unset. Mid-response percentage boundaries use Pi's bounded compact-and-continue lifecycle, so Pi auto-compaction must remain enabled. |
+| Fast mode                                     | Uses the normal tier.                                                                                                                             | Uses the configured Codex service tier.                                                                                                       | `fastMode`: boolean; `true` requests the priority tier.                                                                                                                     |
+| Responses Lite                                | Disabled; supported GPT-5.6 models use ordinary Responses.                                                                                        | Enabled according to Codex model metadata.                                                                                                    | `responsesLite`: boolean; `true` enables Responses Lite.                                                                                                                    |
+| Text and reasoning request controls           | Sends low text verbosity and automatic reasoning summaries; omits the default GPT-5.6 standard mode and sends `reasoning.mode` only for pro mode. | Resolves these controls through Codex configuration, model metadata, and turn state.                                                          | `textVerbosity`, `reasoningSummary`, and `reasoningMode`.                                                                                                                   |
 
 `web.run` is a reserved GPT-5.6 tool name. Its declaration therefore reproduces the complete current Codex post-normalization `SearchCommands` schema and official tool description instead of using Pi's normal compact tool schema. This intentionally omits generated annotations such as `format` and `minimum` that Codex removes before sending the declaration to Responses.
 
@@ -61,9 +61,9 @@ The compatibility baseline is official Codex CLI `0.146.0`, released July 29, 20
 | System instructions         | Pi rebuilds the current system prompt. Responses Lite models prepend it as developer input after `additional_tools`; other models send it through Responses `instructions`. Normal Pi history does not store it as replayed system/developer input. `/reload` updates the next request without rewriting old checkpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | Turn metadata               | Requests send a persisted installation id plus Pi-derived session, thread, context-window, turn, source, sandbox, request-kind, and nested compaction-operation metadata in `client_metadata` and compatible headers. The in-memory context-window number advances after successful compaction. One turn id is reused throughout a Pi agent run, while prewarm has its own id. First-party requests also carry Codex's model-and-tier routing hint. The provider captures the server-issued `x-codex-turn-state` once per agent run, replays it on WebSocket retries, SSE requests, and WebSocket-to-SSE fallback, and records all identity values in transport diagnostics. Pi does not reconstruct prior window number after extension reload/session resume or reproduce workspace Git/parent/subagent/Code Mode metadata. Each marked Pi tree branch receives its own persisted thread UUID. |
 | Cache preparation           | Before the first cache-enabled WebSocket turn, the package prewarms only the stable instruction/tool prefix: ordinary Responses uses empty `input`, while Responses Lite uses `additional_tools` plus the developer instructions. The first generated request then contributes only dynamic conversation input to the continuation. No explicit prompt-cache breakpoints are added.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| Mid-turn compaction         | Provider-boundary percentage compaction installs a checkpoint and continues the intercepted request. Pi threshold compaction normally runs after the agent response; after Codex output-token truncation, the extension queues a hidden continuation so threshold compaction completes before sampling resumes. Official Codex owns this sampling and compaction loop directly.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| Mid-turn compaction         | Provider-boundary percentage compaction preserves a successful `end_turn:false` prefix as its own Pi assistant message, installs a checkpoint, and continues without synthetic model input. Pi threshold compaction normally runs after the agent response; after Codex output-token truncation, the extension queues a hidden continuation so threshold compaction completes before sampling resumes. Official Codex owns this sampling and compaction loop directly.                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | Provider-owned follow-up    | Completed responses with `end_turn: false` continue immediately from completed native output without synthetic user input. Retryable `response.failed` and all `response.incomplete` events are resampled with the official five-retry stream budget, preserving completed output and cumulative usage while excluding unfinished attempt content. A `max_output_tokens` response that exhausts this budget still becomes Pi `stopReason: "length"` and uses the extension's unbounded host-level continuation recovery.                                                                                                                                                                                                                                                                                                                                                                         |
-| Compaction lifecycle events | Percentage compaction writes through Pi's mutable session manager but cannot emit Pi's internal `session_compact` event through the public extension API. Manual, threshold, and overflow compactions initiated by Pi do emit the normal lifecycle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| Compaction lifecycle events | Pre-turn percentage compaction writes through Pi's mutable session manager and cannot emit Pi's internal `session_compact` event through the public extension API. Mid-response percentage boundaries and manual, threshold, or overflow compactions initiated by Pi emit the normal lifecycle.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | Header hooks                | An internal percentage-compaction request reuses the already transformed provider headers. It cannot independently rerun Pi's `before_provider_headers` hook.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | Native retained context     | Deliberately differs from current Codex. The package retains recent user/developer/system messages under the 64k budget before the opaque compaction item. Current Codex applies a second installed-history filter that drops developer/system wrappers and non-real-user messages, can retain eligible structured agent commentary, and trims oversized function outputs before compaction. Pi keeps its existing checkpoint shape by design.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | Tool namespaces             | Responses Lite groups Pi's ordinary function/custom declarations into upstream's canonical `functions` namespace and maps that default namespace back to bare Pi names. Pi registers dotted names such as `web.run` as exact flat identifiers, so the provider converts only the fixed extension-owned allowlist into non-default Responses namespace/member identities and rejects unknown or ambiguously flat namespaced calls.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
@@ -198,7 +198,7 @@ Defaults:
 | `imageGeneration`      | boolean                                              | `true`     | Enables the extension-owned `image_gen.imagegen` tool on selected `openai-codex` models.                                                                                                                                                  |
 | `imageDetail`          | `auto`, `low`, `high`, `original`                    | `auto`     | Sets `input_image.detail` when an image tool result is sent back to the model. It does not change `gpt-image-2` generation quality.                                                                                                       |
 | `webRun`               | boolean                                              | `false`    | Enables the extension-owned `web.run` tool on selected `openai-codex` models. When active, it replaces hosted `web_search` in the Responses tool list.                                                                                    |
-| `autoCompactAtPercent` | number greater than `0` and at most `100`, or `null` | unset      | Adds provider-boundary compaction independently of Pi's normal reserve-token threshold. A project value of `null` disables a global percentage threshold.                                                                                 |
+| `autoCompactAtPercent` | number greater than `0` and at most `100`, or `null` | unset      | Adds provider-boundary compaction independently of Pi's normal reserve-token threshold. Mid-response boundaries require Pi auto-compaction. A project value of `null` disables a global percentage threshold.                             |
 | `webSearch`            | `disabled`, `cached`, `indexed`, `live`              | `disabled` | Controls hosted search and standalone-search external access. `disabled` removes hosted search but leaves an independently enabled `web.run` in cached-only mode; `indexed` prefers indexed content; `live` permits live external access. |
 | `textVerbosity`        | `low`, `medium`, `high`                              | `low`      | Sets Responses API `text.verbosity`.                                                                                                                                                                                                      |
 | `reasoningSummary`     | `auto`, `concise`, `detailed`, `off`                 | `auto`     | Sets `reasoning.summary` when reasoning is enabled; `off` omits the summary parameter.                                                                                                                                                    |

package/extensions/openai-codex-compat/codex-provider.ts

@@ -61,7 +61,11 @@ import {
   type CodexWebSocketResponseHandle,
 } from "./codex-transport.ts";
 import { DEFAULT_CONFIG, type CodexCompatConfig, type ImageDetail } from "./config.ts";
-import { nativeResponseData, NATIVE_RESPONSE_ENTRY_TYPE } from "./native-history.ts";
+import {
+  nativeResponseData,
+  NATIVE_RESPONSE_ENTRY_TYPE,
+  type NativeResponseAttempt,
+} from "./native-history.ts";
 import {
   CODEX_NAMESPACED_TOOL_NAMES,
   CODEX_TEXT_CONTENT_ITEM_TOOL_RESULT_NAMES,
@@ -78,6 +82,7 @@ import { formatProviderError } from "./provider-error.ts";
 const CODEX_PROVIDER = "openai-codex";
 const CODEX_API = "openai-codex-responses";
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+const PROVIDER_COMPACTION_BOUNDARY_STOP_REASON = "completed.end_turn_false.context_limit";
 
 type ConfigResolver = (ctx: ExtensionContext) => CodexCompatConfig;
 
@@ -130,25 +135,30 @@ type CodexTerminalState = {
 
 type CodexAttemptCapture = {
   streamedItems: ResponsesItem[];
-  streamedToolCallKeys: Set<string>;
-  streamedCompletedToolCallKeys: Set<string>;
-  terminalItems?: ResponsesItem[];
+  streamedToolCallIndexes: Set<number>;
+  streamedCompletedToolCallIndexes: Set<number>;
 };
 
 type CodexToolCallAssessment = {
-  allComplete: boolean;
-  authoritativeCount: number;
-  hasToolCalls: boolean;
-  omittedStreamedCount: number;
-  terminalCount: number;
+  completedCount: number;
+  discardedPartialCount: number;
+  hasCompletedCalls: boolean;
+};
+
+type CodexPostToolDisposition = {
+  callIds: string[];
+  response?: JsonRecord;
+  retryAttempt: number;
+  sessionId?: string;
+  terminalType: "response.incomplete" | "response.failed";
+  turnId: string;
+  type: "error" | "retry";
 };
 
 type CodexResponseDecision =
   | "continue_no_tools"
-  | "preserve_terminal_error"
-  | "reject_terminal_stream_mismatch"
   | "retry_original_input"
-  | "return_length_incomplete_call"
+  | "return_compaction_boundary"
   | "return_terminal"
   | "return_tool_use";
 
@@ -217,62 +227,22 @@ function isToolCallItem(item: ResponsesItem): boolean {
   return item.type === "function_call" || item.type === "custom_tool_call";
 }
 
-function toolCallKey(item: ResponsesItem): string {
-  const callId = typeof item["call_id"] === "string" ? item["call_id"] : undefined;
-  const itemId = typeof item.id === "string" ? item.id : undefined;
-  return `${String(item.type)}:${itemId ? `item:${itemId}` : `call:${callId ?? "missing"}`}`;
-}
-
-function hasValidToolCallPayload(item: ResponsesItem): boolean {
-  if (
-    typeof item.id !== "string" ||
-    typeof item["call_id"] !== "string" ||
-    typeof item.name !== "string"
-  ) {
-    return false;
-  }
-  if (item.type === "custom_tool_call") return typeof item.input === "string";
-  if (item.type !== "function_call" || typeof item.arguments !== "string") return false;
-  try {
-    return isObject(JSON.parse(item.arguments));
-  } catch {
-    return false;
-  }
-}
-
-function toolCallIsComplete(
-  item: ResponsesItem,
-  capture: CodexAttemptCapture,
-  terminalType: CodexTerminalState["type"],
-): boolean {
-  if (!hasValidToolCallPayload(item)) return false;
-  const status = typeof item["status"] === "string" ? item["status"] : undefined;
-  if (status !== undefined) return status === "completed";
-  if (capture.streamedCompletedToolCallKeys.has(toolCallKey(item))) return true;
-  return terminalType === "response.completed";
+function eventOutputIndex(event: JsonRecord): number {
+  return typeof event["output_index"] === "number" ? event["output_index"] : 0;
 }
 
 function assessAttemptToolCalls(
   items: readonly ResponsesItem[],
   capture: CodexAttemptCapture,
-  terminalType: CodexTerminalState["type"],
 ): CodexToolCallAssessment {
-  const calls = items.filter(isToolCallItem);
-  const authoritativeKeys = new Set(calls.map(toolCallKey));
-  const omittedStreamedCount = [...capture.streamedToolCallKeys].filter(
-    (key) => !authoritativeKeys.has(key),
+  const completedCount = items.filter(isToolCallItem).length;
+  const discardedPartialCount = [...capture.streamedToolCallIndexes].filter(
+    (index) => !capture.streamedCompletedToolCallIndexes.has(index),
   ).length;
-  const hasToolCalls = calls.length > 0 || capture.streamedToolCallKeys.size > 0;
   return {
-    hasToolCalls,
-    allComplete:
-      hasToolCalls &&
-      omittedStreamedCount === 0 &&
-      calls.length > 0 &&
-      calls.every((item) => toolCallIsComplete(item, capture, terminalType)),
-    authoritativeCount: calls.length,
-    omittedStreamedCount,
-    terminalCount: capture.terminalItems?.filter(isToolCallItem).length ?? 0,
+    completedCount,
+    discardedPartialCount,
+    hasCompletedCalls: completedCount > 0,
   };
 }
 
@@ -291,6 +261,7 @@ function responseDecisionDiagnostic(options: {
   capture: CodexAttemptCapture;
   decision: CodexResponseDecision;
   incompleteReason?: string;
+  postToolDisposition?: "continue" | "error" | "retry";
   terminalState: CodexTerminalState;
   toolCalls: CodexToolCallAssessment;
 }): AssistantMessageDiagnostic | undefined {
@@ -302,8 +273,7 @@ function responseDecisionDiagnostic(options: {
     options.attempt > 1 ||
     options.terminalState.type !== "response.completed" ||
     endTurn === false ||
-    options.toolCalls.hasToolCalls ||
-    options.toolCalls.omittedStreamedCount > 0;
+    options.capture.streamedToolCallIndexes.size > 0;
   if (!nontrivial) return undefined;
 
   return {
@@ -314,14 +284,12 @@ function responseDecisionDiagnostic(options: {
       terminalType: options.terminalState.type ?? "missing",
       ...(options.incompleteReason ? { incompleteReason: options.incompleteReason } : {}),
       ...(endTurn === undefined ? {} : { endTurn }),
-      itemSource: options.capture.terminalItems ? "terminal" : "stream-fallback",
       outputItemTypes: outputItemTypeCounts(options.attemptItems),
-      streamedCallsStarted: options.capture.streamedToolCallKeys.size,
-      streamedCallsCompleted: options.capture.streamedCompletedToolCallKeys.size,
-      terminalCalls: options.toolCalls.terminalCount,
-      authoritativeCalls: options.toolCalls.authoritativeCount,
-      terminalOmittedStreamedCalls: options.toolCalls.omittedStreamedCount,
-      allCallsComplete: options.toolCalls.allComplete,
+      streamedCallsStarted: options.capture.streamedToolCallIndexes.size,
+      streamedCallsDone: options.capture.streamedCompletedToolCallIndexes.size,
+      returnedCalls: options.toolCalls.completedCount,
+      discardedPartialCalls: options.toolCalls.discardedPartialCount,
+      ...(options.postToolDisposition ? { postToolDisposition: options.postToolDisposition } : {}),
       decision: options.decision,
     },
   };
@@ -340,28 +308,17 @@ function captureRawEvents(
           isResponsesItem(event.item) &&
           isToolCallItem(event.item)
         ) {
-          capture.streamedToolCallKeys.add(toolCallKey(event.item));
+          capture.streamedToolCallIndexes.add(eventOutputIndex(event));
         }
         if (event.type === "response.output_item.done" && isResponsesItem(event.item)) {
           const item = structuredClone(event.item);
           capture.streamedItems.push(item);
           if (isToolCallItem(item)) {
-            const key = toolCallKey(item);
-            capture.streamedToolCallKeys.add(key);
-            capture.streamedCompletedToolCallKeys.add(key);
+            const index = eventOutputIndex(event);
+            capture.streamedToolCallIndexes.add(index);
+            capture.streamedCompletedToolCallIndexes.add(index);
           }
         }
-        if (
-          (event.type === "response.completed" ||
-            event.type === "response.incomplete" ||
-            event.type === "response.failed") &&
-          isObject(event.response) &&
-          Array.isArray(event.response["output"])
-        ) {
-          capture.terminalItems = event.response["output"]
-            .filter(isResponsesItem)
-            .map((item) => structuredClone(item));
-        }
         if (
           terminalState &&
           (event.type === "response.completed" ||
@@ -449,6 +406,22 @@ function accumulateUsage(previous: Usage, current: Usage): Usage {
   };
 }
 
+function reachedProviderCompactionThreshold(
+  scope: RuntimeScope | undefined,
+  usage: Usage,
+  model: Model<any>,
+): boolean {
+  const threshold = scope?.config.autoCompactAtPercent;
+  if (threshold === undefined || model.contextWindow <= 0 || usage.output >= model.maxTokens) {
+    return false;
+  }
+  const contextTokens =
+    usage.totalTokens > 0
+      ? usage.totalTokens
+      : usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+  return contextTokens > 0 && (contextTokens / model.contextWindow) * 100 >= threshold;
+}
+
 function retryableResponseFailure(response: JsonRecord | undefined): boolean {
   const error = isObject(response?.["error"]) ? response["error"] : undefined;
   const code = typeof error?.["code"] === "string" ? error["code"].toLowerCase() : "";
@@ -462,6 +435,64 @@ function retryableResponseFailure(response: JsonRecord | undefined): boolean {
   );
 }
 
+function terminalReason(terminalState: CodexTerminalState): string | undefined {
+  if (terminalState.type === "response.failed") {
+    const error = isObject(terminalState.response?.["error"])
+      ? terminalState.response["error"]
+      : undefined;
+    return typeof error?.["code"] === "string" ? error["code"] : undefined;
+  }
+  if (terminalState.type === "response.incomplete") {
+    const details = isObject(terminalState.response?.["incomplete_details"])
+      ? terminalState.response["incomplete_details"]
+      : undefined;
+    return typeof details?.["reason"] === "string" ? details["reason"] : undefined;
+  }
+  return undefined;
+}
+
+function terminalErrorMessage(disposition: CodexPostToolDisposition): string {
+  if (disposition.terminalType === "response.failed") {
+    const error = isObject(disposition.response?.["error"])
+      ? disposition.response["error"]
+      : undefined;
+    return typeof error?.["message"] === "string" ? error["message"] : "Codex response failed";
+  }
+  const details = isObject(disposition.response?.["incomplete_details"])
+    ? disposition.response["incomplete_details"]
+    : undefined;
+  const reason = typeof details?.["reason"] === "string" ? details["reason"] : undefined;
+  return reason
+    ? `Response incomplete: ${reason}`
+    : "Response incomplete without a provider reason";
+}
+
+function completedAttemptToolCallIds(
+  message: AssistantMessage,
+  attempt: CodexStreamAttemptState,
+): string[] {
+  return [...attempt.completedContentIndexes]
+    .sort((left, right) => left - right)
+    .flatMap((index) => {
+      const block = message.content[index];
+      return block?.type === "toolCall" ? [block.id] : [];
+    });
+}
+
+function assertLinkedToolOutputs(context: Context, disposition: CodexPostToolDisposition): void {
+  const outputIds = new Set(
+    context.messages.flatMap((message) =>
+      message.role === "toolResult" ? [message.toolCallId] : [],
+    ),
+  );
+  const missing = disposition.callIds.filter((callId) => !outputIds.has(callId));
+  if (missing.length > 0) {
+    throw new Error(
+      `Codex cannot process the ${disposition.terminalType} response until Pi records tool output for: ${missing.join(", ")}`,
+    );
+  }
+}
+
 function responseRetryDelayMs(baseDelayMs: number, attempt: number): number {
   if (baseDelayMs <= 0) return 0;
   const exponential = baseDelayMs * 2 ** Math.max(0, attempt - 1);
@@ -598,6 +629,7 @@ export class CodexProviderRuntime {
   private readonly prewarmedTemplates = new Set<string>();
   private readonly requestTails = new Map<string, Promise<void>>();
   private readonly activeAgentTurns = new Map<string, ActiveAgentTurn>();
+  private readonly postToolDispositions = new Map<string, CodexPostToolDisposition>();
   private readonly windowNumbers = new Map<string, number>();
   private readonly activeThreadIds = new Map<string, string>();
   private readonly pi: ExtensionAPI;
@@ -646,7 +678,9 @@ export class CodexProviderRuntime {
   }
 
   beginAgentTurn(ctx: ExtensionContext): void {
-    this.activeAgentTurns.set(ctx.sessionManager.getSessionId(), {
+    const sessionId = ctx.sessionManager.getSessionId();
+    this.clearPostToolDispositions((disposition) => disposition.sessionId === sessionId);
+    this.activeAgentTurns.set(sessionId, {
       turnId: uuidv7(),
       startedAtUnixMs: Date.now(),
       turnState: new CodexTurnState(),
@@ -654,7 +688,12 @@ export class CodexProviderRuntime {
   }
 
   endAgentTurn(ctx: ExtensionContext): void {
-    this.activeAgentTurns.delete(ctx.sessionManager.getSessionId());
+    const sessionId = ctx.sessionManager.getSessionId();
+    const agentTurn = this.activeAgentTurns.get(sessionId);
+    if (agentTurn) {
+      this.clearPostToolDispositions((disposition) => disposition.turnId === agentTurn.turnId);
+    }
+    this.activeAgentTurns.delete(sessionId);
   }
 
   updateSessionConfig(sessionId: string, config: CodexCompatConfig): void {
@@ -679,6 +718,46 @@ export class CodexProviderRuntime {
     );
   }
 
+  private rememberPostToolDisposition(disposition: CodexPostToolDisposition): void {
+    const callIds = new Set(disposition.callIds);
+    if ([...callIds].some((callId) => this.postToolDispositions.has(callId))) {
+      throw new Error("Codex returned a tool call that already has a pending disposition.");
+    }
+    for (const callId of callIds) this.postToolDispositions.set(callId, disposition);
+  }
+
+  private findPostToolDisposition(context: Context): CodexPostToolDisposition | undefined {
+    const matches = new Set<CodexPostToolDisposition>();
+    for (const message of context.messages) {
+      if (message.role !== "assistant") continue;
+      for (const block of message.content) {
+        if (block.type !== "toolCall") continue;
+        const disposition = this.postToolDispositions.get(block.id);
+        if (disposition) matches.add(disposition);
+      }
+    }
+    if (matches.size > 1) {
+      throw new Error("Codex context contains multiple pending post-tool dispositions.");
+    }
+    return matches.values().next().value;
+  }
+
+  private forgetPostToolDisposition(disposition: CodexPostToolDisposition): void {
+    for (const callId of disposition.callIds) {
+      if (this.postToolDispositions.get(callId) === disposition) {
+        this.postToolDispositions.delete(callId);
+      }
+    }
+  }
+
+  private clearPostToolDispositions(
+    shouldClear: (disposition: CodexPostToolDisposition) => boolean,
+  ): void {
+    for (const [callId, disposition] of this.postToolDispositions) {
+      if (shouldClear(disposition)) this.postToolDispositions.delete(callId);
+    }
+  }
+
   private metadataIdentity(
     metadataSessionId: string | undefined,
     turn?: ActiveAgentTurn,
@@ -737,6 +816,7 @@ export class CodexProviderRuntime {
     this.clearPrewarmState(sessionId);
     this.requestTails.delete(sessionId);
     this.activeAgentTurns.delete(sessionId);
+    this.clearPostToolDispositions((disposition) => disposition.sessionId === sessionId);
     for (const key of this.windowNumbers.keys()) {
       if (key.startsWith(`${sessionId}\0`)) this.windowNumbers.delete(key);
     }
@@ -1161,6 +1241,7 @@ export class CodexProviderRuntime {
       };
       const runtimeSessionId = requestOptions.sessionId;
       let releaseRequest = () => {};
+      let registeredPostToolDisposition: CodexPostToolDisposition | undefined;
       try {
         const accountId = validateCodexAuthentication(model, requestOptions.apiKey);
         releaseRequest = await this.acquireRequest(runtimeSessionId, requestOptions.signal);
@@ -1169,6 +1250,26 @@ export class CodexProviderRuntime {
           requestOptions.cacheRetention === "none" ? undefined : codexCacheKey(runtimeSessionId);
         const agentTurn = this.agentTurn(runtimeSessionId);
         const responsesLiteEnabled = this.responsesLiteEnabled(runtimeSessionId);
+        let carriedResponseRetries = 0;
+        const pendingPostToolDisposition = this.findPostToolDisposition(context);
+        if (pendingPostToolDisposition) {
+          assertLinkedToolOutputs(context, pendingPostToolDisposition);
+          this.forgetPostToolDisposition(pendingPostToolDisposition);
+          if (
+            pendingPostToolDisposition.type === "error" ||
+            pendingPostToolDisposition.retryAttempt > this.responseRetryPolicy.maxRetries
+          ) {
+            throw new Error(terminalErrorMessage(pendingPostToolDisposition));
+          }
+          carriedResponseRetries = pendingPostToolDisposition.retryAttempt;
+          await waitForResponseRetry(
+            responseRetryDelayMs(
+              this.responseRetryPolicy.baseDelayMs,
+              pendingPostToolDisposition.retryAttempt,
+            ),
+            requestOptions.signal,
+          );
+        }
         const grammarToolInputProperties = createGrammarToolInputProperties(
           context.tools,
           (model.compat as CodexCompat | undefined)?.supportsOpenAIGrammarTools ?? false,
@@ -1217,6 +1318,7 @@ export class CodexProviderRuntime {
         );
 
         const rawItems: ResponsesItem[] = [];
+        const nativeAttempts: NativeResponseAttempt[] = [];
         const prewarmDiagnostics: CodexTransportDiagnostic[] = [];
         await this.maybePrewarm({
           model,
@@ -1255,20 +1357,19 @@ export class CodexProviderRuntime {
           },
         };
         let responseRequests = 0;
-        let responseRetries = 0;
+        let responseRetries = carriedResponseRetries;
         while (true) {
           responseRequests += 1;
           const attemptCapture: CodexAttemptCapture = {
             streamedItems: [],
-            streamedToolCallKeys: new Set(),
-            streamedCompletedToolCallKeys: new Set(),
+            streamedToolCallIndexes: new Set(),
+            streamedCompletedToolCallIndexes: new Set(),
           };
           const terminalState: CodexTerminalState = {};
           const attemptState: CodexStreamAttemptState = {
             startedContentIndexes: new Set(),
             completedContentIndexes: new Set(),
           };
-          const contentLengthBeforeAttempt = output.content.length;
           const usageBeforeAttempt = structuredClone(output.usage);
           output.usage = emptyUsage();
           try {
@@ -1300,14 +1401,18 @@ export class CodexProviderRuntime {
             throw error;
           }
           output.usage = accumulateUsage(usageBeforeAttempt, output.usage);
-          // A terminal response.output is the complete provider snapshot when present.
-          // Stream-completed items are the fallback for transports that omit that field.
-          const attemptItems = attemptCapture.terminalItems ?? attemptCapture.streamedItems;
-          const toolCalls = assessAttemptToolCalls(
-            attemptItems,
-            attemptCapture,
-            terminalState.type,
-          );
+          // `response.output_item.done` is Codex's item-level commit point. Terminal
+          // response.output snapshots are deliberately ignored.
+          const attemptItems = attemptCapture.streamedItems;
+          if (terminalState.type) {
+            const reason = terminalReason(terminalState);
+            nativeAttempts.push({
+              itemCount: attemptItems.length,
+              terminalType: terminalState.type,
+              ...(reason ? { terminalReason: reason } : {}),
+            });
+          }
+          const toolCalls = assessAttemptToolCalls(attemptItems, attemptCapture);
           const incompleteDetails = isObject(terminalState.response?.["incomplete_details"])
             ? terminalState.response["incomplete_details"]
             : undefined;
@@ -1315,67 +1420,58 @@ export class CodexProviderRuntime {
             typeof incompleteDetails?.["reason"] === "string"
               ? incompleteDetails["reason"]
               : undefined;
-          const maxOutputIncomplete =
-            terminalState.type === "response.incomplete" &&
-            incompleteReason === "max_output_tokens";
-          const recordDecision = (decision: CodexResponseDecision): void => {
+          const recordDecision = (
+            decision: CodexResponseDecision,
+            postToolDisposition?: "continue" | "error" | "retry",
+          ): void => {
             const diagnostic = responseDecisionDiagnostic({
               attempt: responseRequests,
               attemptItems,
               capture: attemptCapture,
               decision,
               ...(incompleteReason ? { incompleteReason } : {}),
+              ...(postToolDisposition ? { postToolDisposition } : {}),
               terminalState,
               toolCalls,
             });
             if (diagnostic) output.diagnostics = [...(output.diagnostics ?? []), diagnostic];
           };
 
-          // Tool calls create a client-execution boundary. Never append them to an
-          // internal provider continuation before Pi can return the linked outputs.
-          if (toolCalls.hasToolCalls) {
-            if (
-              toolCalls.allComplete &&
-              ((terminalState.type === "response.completed" && output.stopReason === "toolUse") ||
-                maxOutputIncomplete)
-            ) {
-              discardIncompleteAttemptContent(output, attemptState);
-              rawItems.push(...attemptItems.map((item) => structuredClone(item)));
-              output.stopReason = "toolUse";
-              delete output.errorMessage;
-              recordDecision("return_tool_use");
-              break;
+          // Return each done tool call before processing an unsuccessful response
+          // terminal. Pi will execute the completed subset; started-only siblings
+          // are discarded and never enter provider history.
+          if (toolCalls.hasCompletedCalls) {
+            const callIds = completedAttemptToolCallIds(output, attemptState);
+            if (callIds.length !== toolCalls.completedCount) {
+              throw new Error("Codex completed tool-call items could not be mapped to Pi calls.");
             }
-
-            output.content.splice(contentLengthBeforeAttempt);
+            let postToolDisposition: "continue" | "error" | "retry" = "continue";
             if (
-              terminalState.type === "response.failed" &&
-              retryableResponseFailure(terminalState.response) &&
-              responseRetries < this.responseRetryPolicy.maxRetries
+              terminalState.type === "response.incomplete" ||
+              terminalState.type === "response.failed"
             ) {
-              responseRetries += 1;
-              output.stopReason = "pending";
-              delete output.errorMessage;
-              delete output.rawStopReason;
-              recordDecision("retry_original_input");
-              await waitForResponseRetry(
-                responseRetryDelayMs(this.responseRetryPolicy.baseDelayMs, responseRetries),
-                requestOptions.signal,
-              );
-              continue;
-            }
-            if (terminalState.type === "response.completed" && output.stopReason !== "error") {
-              output.stopReason = "length";
-              output.rawStopReason = "incomplete.tool_call";
-              delete output.errorMessage;
+              const retryable =
+                terminalState.type === "response.incomplete" ||
+                retryableResponseFailure(terminalState.response);
+              postToolDisposition = retryable ? "retry" : "error";
+              registeredPostToolDisposition = {
+                callIds,
+                ...(terminalState.response
+                  ? { response: structuredClone(terminalState.response) }
+                  : {}),
+                retryAttempt: retryable ? responseRetries + 1 : responseRetries,
+                ...(runtimeSessionId ? { sessionId: runtimeSessionId } : {}),
+                terminalType: terminalState.type,
+                turnId: agentTurn.turnId,
+                type: postToolDisposition,
+              };
+              this.rememberPostToolDisposition(registeredPostToolDisposition);
             }
-            recordDecision(
-              toolCalls.omittedStreamedCount > 0
-                ? "reject_terminal_stream_mismatch"
-                : output.stopReason === "length"
-                  ? "return_length_incomplete_call"
-                  : "preserve_terminal_error",
-            );
+            discardIncompleteAttemptContent(output, attemptState);
+            rawItems.push(...attemptItems.map((item) => structuredClone(item)));
+            output.stopReason = "toolUse";
+            delete output.errorMessage;
+            recordDecision("return_tool_use", postToolDisposition);
             break;
           }
 
@@ -1396,7 +1492,9 @@ export class CodexProviderRuntime {
             output.stopReason = "pending";
             delete output.errorMessage;
             delete output.rawStopReason;
-            recordDecision("continue_no_tools");
+            recordDecision(
+              attemptItems.length === 0 ? "retry_original_input" : "continue_no_tools",
+            );
             await waitForResponseRetry(
               responseRetryDelayMs(this.responseRetryPolicy.baseDelayMs, responseRetries),
               requestOptions.signal,
@@ -1408,6 +1506,18 @@ export class CodexProviderRuntime {
             terminalState.type === "response.completed" &&
             terminalState.response?.["end_turn"] === false
           ) {
+            const scope = runtimeSessionId ? this.scopes.get(runtimeSessionId) : undefined;
+            if (reachedProviderCompactionThreshold(scope, output.usage, model)) {
+              // Pi 0.84 has no provider event that can split one stream into two
+              // assistant messages. Return the committed prefix as a recoverable
+              // length boundary so Pi persists B1, runs native overflow compaction,
+              // and continues from K without adding model-visible input.
+              output.stopReason = "length";
+              output.rawStopReason = PROVIDER_COMPACTION_BOUNDARY_STOP_REASON;
+              delete output.errorMessage;
+              recordDecision("return_compaction_boundary");
+              break;
+            }
             if (!nextBody) {
               throw new Error(
                 "Codex requested a follow-up response, but its completed output could not be appended to request history.",
@@ -1463,7 +1573,7 @@ export class CodexProviderRuntime {
           if (!output.responseId) throw new Error("Codex response is missing a response id.");
           this.pi.appendEntry(
             NATIVE_RESPONSE_ENTRY_TYPE,
-            nativeResponseData(model.id, output.responseId, rawItems),
+            nativeResponseData(model.id, output.responseId, rawItems, nativeAttempts),
           );
         }
         try {
@@ -1484,6 +1594,9 @@ export class CodexProviderRuntime {
         stream.push({ type: "done", reason: output.stopReason, message: output });
         stream.end();
       } catch (error) {
+        if (registeredPostToolDisposition) {
+          this.forgetPostToolDisposition(registeredPostToolDisposition);
+        }
         clearStreamingScratchState(output);
         output.stopReason = requestOptions.signal?.aborted ? "aborted" : "error";
         output.errorMessage = formatProviderError(error);

package/extensions/openai-codex-compat/codex-stream.ts

@@ -141,11 +141,6 @@ function appendCustomInput(
   return delta;
 }
 
-function responseItems(value: unknown): JsonRecord[] {
-  if (!Array.isArray(value)) return [];
-  return value.filter(isObject);
-}
-
 function itemContentText(item: JsonRecord): string {
   if (!Array.isArray(item.content)) return "";
   return item.content
@@ -210,7 +205,7 @@ export async function processCodexStream(
   let terminal = false;
   const slots = new Map<number, OutputSlot>();
   const completedOutputItems = new Set<string>();
-  const reasoningById = new Map<string, ThinkingContent>();
+  const completedToolCallContentIndexes = new Set<number>();
   const applyMessagePhaseStopReason = (item: JsonRecord): void => {
     if (item.type === "message" && item["phase"] === "final_answer") {
       output.stopReason = "stop";
@@ -336,7 +331,6 @@ export async function processCodexStream(
     if (item.type === "reasoning" && slot?.type === "thinking") {
       slot.block.thinking = reasoningText(item) || slot.block.thinking;
       slot.block.thinkingSignature = JSON.stringify(item);
-      if (typeof item.id === "string") reasoningById.set(item.id, slot.block);
       stream.push({
         type: "thinking_end",
         contentIndex: slot.contentIndex,
@@ -375,6 +369,7 @@ export async function processCodexStream(
         partial: output,
       });
       trackCompleted(slot);
+      completedToolCallContentIndexes.add(slot.contentIndex);
       slots.delete(index);
     } else if (item.type === "custom_tool_call" && slot?.type === "toolCall") {
       slot.block.name = piToolCallName(item);
@@ -388,6 +383,7 @@ export async function processCodexStream(
         partial: output,
       });
       trackCompleted(slot);
+      completedToolCallContentIndexes.add(slot.contentIndex);
       slots.delete(index);
     }
   };
@@ -424,20 +420,6 @@ export async function processCodexStream(
       output.usage,
       typeof response.service_tier === "string" ? response.service_tier : undefined,
     );
-    const terminalItems = responseItems(response["output"]);
-    terminalItems.forEach((item, index) => completeOutputItem(index, item));
-    for (const item of terminalItems) {
-      if (item.type !== "reasoning" || typeof item.id !== "string") continue;
-      const block = reasoningById.get(item.id);
-      if (!block?.thinkingSignature || typeof item.encrypted_content !== "string") continue;
-      const stored = JSON.parse(block.thinkingSignature) as JsonRecord;
-      if (typeof stored.encrypted_content !== "string") {
-        block.thinkingSignature = JSON.stringify({
-          ...stored,
-          encrypted_content: item.encrypted_content,
-        });
-      }
-    }
     const status = normalizeCodexStatus(response["status"]);
     const incompleteDetails = isObject(response["incomplete_details"])
       ? response["incomplete_details"]
@@ -452,7 +434,12 @@ export async function processCodexStream(
     output.stopReason = mappedStop.stopReason;
     if (mappedStop.errorMessage === undefined) delete output.errorMessage;
     else output.errorMessage = mappedStop.errorMessage;
-    if (output.stopReason === "stop" && output.content.some((block) => block.type === "toolCall")) {
+    if (
+      output.stopReason === "stop" &&
+      [...completedToolCallContentIndexes].some(
+        (contentIndex) => output.content[contentIndex]?.type === "toolCall",
+      )
+    ) {
       output.stopReason = "toolUse";
     }
   };

package/extensions/openai-codex-compat/codex-transport.ts

@@ -1910,16 +1910,6 @@ async function* requestWebSocket(
           responseCompleted = true;
         }
         if (typeof event.response.id === "string") responseId = event.response.id;
-        if (Array.isArray(event.response["output"])) {
-          const terminalItems = event.response["output"].filter(isObject);
-          if (terminalItems.length > 0) {
-            responseItems.splice(
-              0,
-              responseItems.length,
-              ...terminalItems.map((item) => structuredClone(item)),
-            );
-          }
-        }
       }
       const normalized = normalizeEvent(event);
       if (!normalized) continue;

package/extensions/openai-codex-compat/compaction-checkpoint.ts

@@ -14,7 +14,7 @@ import {
   isResponsesItem,
   type ResponsesItem,
 } from "./codex-protocol.ts";
-import { nativeResponseOverrides } from "./native-history.ts";
+import { nativeCommittedPrefixBeforeOverflow, nativeResponseOverrides } from "./native-history.ts";
 import {
   CODEX_NAMESPACED_TOOL_NAMES,
   CODEX_TEXT_CONTENT_ITEM_TOOL_RESULT_NAMES,
@@ -279,10 +279,11 @@ export function providerHistory(options: {
   allTools: readonly ToolInfo[];
   grammarToolInputProperties?: GrammarToolInputProperties;
   imageDetail?: ImageDetail;
-  dropLatestFailedAssistant?: boolean;
+  recoverLatestOverflowPrefix?: boolean;
 }): ResponsesItem[] {
   const branch = [...options.branch];
-  if (options.dropLatestFailedAssistant) {
+  let recoveredPrefix: ResponsesItem[] = [];
+  if (options.recoverLatestOverflowPrefix) {
     const index = branch.findLastIndex(
       (entry) => entry.type === "message" && entry.message.role === "assistant",
     );
@@ -292,6 +293,14 @@ export function providerHistory(options: {
       entry.message.role === "assistant" &&
       (entry.message.stopReason === "error" || entry.message.stopReason === "aborted")
     ) {
+      if (entry.message.stopReason === "error" && entry.message.responseId) {
+        recoveredPrefix =
+          nativeCommittedPrefixBeforeOverflow(
+            branch,
+            options.wireModel.id,
+            entry.message.responseId,
+          ) ?? [];
+      }
       branch.splice(index, 1);
     }
   }
@@ -317,16 +326,20 @@ export function providerHistory(options: {
         options.imageDetail,
         nativeAssistantItems,
       ),
+      ...recoveredPrefix,
     ];
   }
 
   const context = buildSessionContext(branch);
-  return encodeMessages(
-    options.wireModel,
-    convertToLlm(context.messages),
-    options.allTools,
-    options.grammarToolInputProperties ?? new Map(),
-    options.imageDetail ?? "auto",
-    nativeAssistantItems,
-  );
+  return [
+    ...encodeMessages(
+      options.wireModel,
+      convertToLlm(context.messages),
+      options.allTools,
+      options.grammarToolInputProperties ?? new Map(),
+      options.imageDetail ?? "auto",
+      nativeAssistantItems,
+    ),
+    ...recoveredPrefix,
+  ];
 }

package/extensions/openai-codex-compat/config.ts

@@ -31,9 +31,9 @@ export interface CodexCompatConfig {
   /** Expose the standalone Codex web-search namespace tool. */
   webRun: boolean;
   /**
-   * Compact at a provider request boundary when context usage reaches this
-   * percentage. Omit it to rely only on Pi's compaction lifecycle (`/compact`,
-   * threshold compaction, and overflow recovery).
+   * Compact at provider request boundaries when context usage reaches this
+   * percentage. Mid-response boundaries use Pi's bounded compact-and-continue
+   * lifecycle, so Pi auto-compaction must remain enabled.
    */
   autoCompactAtPercent?: number;
   webSearch: WebSearchMode;

package/extensions/openai-codex-compat/native-history.ts

@@ -3,6 +3,13 @@ import { isObject, isResponsesItem, type ResponsesItem } from "./codex-protocol.
 
 export const NATIVE_RESPONSE_ENTRY_TYPE = "openai-codex-compat-native-response";
 export const NATIVE_RESPONSE_FORMAT_VERSION = 1;
+export const NATIVE_RESPONSE_ITEM_COMMIT = "response.output_item.done";
+
+export type NativeResponseAttempt = {
+  itemCount: number;
+  terminalType: "response.completed" | "response.incomplete" | "response.failed";
+  terminalReason?: string;
+};
 
 export type NativeResponseData = {
   kind: typeof NATIVE_RESPONSE_ENTRY_TYPE;
@@ -10,12 +17,15 @@ export type NativeResponseData = {
   modelId: string;
   responseId: string;
   items: ResponsesItem[];
+  itemCommit?: typeof NATIVE_RESPONSE_ITEM_COMMIT;
+  attempts?: NativeResponseAttempt[];
 };
 
 export function nativeResponseData(
   modelId: string,
   responseId: string,
   items: readonly ResponsesItem[],
+  attempts?: readonly NativeResponseAttempt[],
 ): NativeResponseData {
   return {
     kind: NATIVE_RESPONSE_ENTRY_TYPE,
@@ -23,6 +33,14 @@ export function nativeResponseData(
     modelId,
     responseId,
     items: items.map((item) => structuredClone(item)),
+    itemCommit: NATIVE_RESPONSE_ITEM_COMMIT,
+    ...(attempts
+      ? {
+          attempts: attempts.map((attempt) => ({
+            ...attempt,
+          })),
+        }
+      : {}),
   };
 }
 
@@ -45,15 +63,111 @@ export function parseNativeResponse(value: unknown): NativeResponseData | undefi
   }
   if (items.length === 0) return undefined;
 
+  const rawItemCommit = value["itemCommit"];
+  if (rawItemCommit !== undefined && rawItemCommit !== NATIVE_RESPONSE_ITEM_COMMIT) {
+    return undefined;
+  }
+  const rawAttempts = value["attempts"];
+  let attempts: NativeResponseAttempt[] | undefined;
+  if (rawAttempts !== undefined) {
+    if (!Array.isArray(rawAttempts)) return undefined;
+    attempts = [];
+    for (const rawAttempt of rawAttempts) {
+      if (
+        !isObject(rawAttempt) ||
+        !Number.isSafeInteger(rawAttempt["itemCount"]) ||
+        (rawAttempt["itemCount"] as number) < 0 ||
+        (rawAttempt["terminalType"] !== "response.completed" &&
+          rawAttempt["terminalType"] !== "response.incomplete" &&
+          rawAttempt["terminalType"] !== "response.failed") ||
+        (rawAttempt["terminalReason"] !== undefined &&
+          typeof rawAttempt["terminalReason"] !== "string")
+      ) {
+        return undefined;
+      }
+      attempts.push({
+        itemCount: rawAttempt["itemCount"] as number,
+        terminalType: rawAttempt["terminalType"],
+        ...(typeof rawAttempt["terminalReason"] === "string"
+          ? { terminalReason: rawAttempt["terminalReason"] }
+          : {}),
+      });
+    }
+  }
+
   return {
     kind: NATIVE_RESPONSE_ENTRY_TYPE,
     version: NATIVE_RESPONSE_FORMAT_VERSION,
     modelId: value.modelId,
     responseId: value["responseId"],
     items,
+    ...(rawItemCommit === NATIVE_RESPONSE_ITEM_COMMIT
+      ? { itemCommit: NATIVE_RESPONSE_ITEM_COMMIT }
+      : {}),
+    ...(attempts ? { attempts } : {}),
   };
 }
 
+function linkedToolCalls(items: readonly ResponsesItem[]): boolean {
+  const unresolved = new Set<string>();
+  for (const item of items) {
+    if (item.type === "function_call" || item.type === "custom_tool_call") {
+      if (typeof item["call_id"] !== "string" || unresolved.has(item["call_id"])) return false;
+      unresolved.add(item["call_id"]);
+      continue;
+    }
+    if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
+      if (typeof item["call_id"] !== "string" || !unresolved.delete(item["call_id"])) {
+        return false;
+      }
+    }
+  }
+  return unresolved.size === 0;
+}
+
+/**
+ * Recover only done items from attempts completed before a final context-overflow
+ * subrequest. Older native entries remain replayable but lack enough provenance
+ * for this recovery path.
+ */
+export function nativeCommittedPrefixBeforeOverflow(
+  branch: readonly SessionEntry[],
+  modelId: string,
+  responseId: string,
+): ResponsesItem[] | undefined {
+  for (let index = branch.length - 1; index >= 0; index--) {
+    const entry = branch[index]!;
+    if (entry.type !== "custom" || entry.customType !== NATIVE_RESPONSE_ENTRY_TYPE) continue;
+    const parsed = parseNativeResponse(entry.data);
+    if (!parsed) {
+      throw new Error(`Codex native response entry ${entry.id} is corrupt.`);
+    }
+    if (parsed.modelId !== modelId || parsed.responseId !== responseId) continue;
+    if (parsed.itemCommit !== NATIVE_RESPONSE_ITEM_COMMIT || !parsed.attempts) return undefined;
+    if (parsed.attempts.length < 2) return undefined;
+    if (
+      parsed.attempts.reduce((total, attempt) => total + attempt.itemCount, 0) !==
+      parsed.items.length
+    ) {
+      return undefined;
+    }
+
+    const finalAttempt = parsed.attempts.at(-1);
+    if (
+      finalAttempt?.terminalType !== "response.failed" ||
+      finalAttempt.terminalReason?.toLowerCase() !== "context_length_exceeded"
+    ) {
+      return undefined;
+    }
+    const prefixLength = parsed.items.length - finalAttempt.itemCount;
+    if (prefixLength <= 0) return undefined;
+    const prefix = parsed.items.slice(0, prefixLength);
+    if (!linkedToolCalls(prefix)) return undefined;
+    return prefix.map((item) => structuredClone(item));
+  }
+  return undefined;
+}
+
 /** Load native assistant output overrides from the active Pi branch. */
 export function nativeResponseOverrides(
   branch: readonly SessionEntry[],

package/extensions/openai-codex-compat/remote-compaction.ts

@@ -163,7 +163,7 @@ export default function registerRemoteCompaction(
         allTools,
         grammarToolInputProperties,
         imageDetail: config.imageDetail,
-        dropLatestFailedAssistant: event.reason === "overflow" && event.willRetry,
+        recoverLatestOverflowPrefix: event.reason === "overflow" && event.willRetry,
       });
       const template =
         matching?.payload ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"