pi-openai-codex-compat 0.0.10-alpha.7 → 0.0.10

package/CHANGELOG.md

@@ -2,8 +2,16 @@
 
 ## Unreleased
 
+## 0.0.10 - 2026-09-20
+
 ### Added
 
+- Add the `pi-apply-patch parse` command-line entry point, which parses a
+  Codex patch document from a file or standard input and prints its
+  operations as JSON without touching the filesystem.
+- Support `gpt-6-astra` for opt-in Responses Lite requests and `pro` reasoning
+  mode, without changing either setting's default.
+
 - Add configurable Codex `exec_command` + `write_stdin` and `shell_command`
   command surfaces, defaulting to persistent unified exec and replacing only
   an active Pi `bash` tool. Command output follows Pi's 2,000-line/50-KiB tail
@@ -18,6 +26,11 @@
 
 ### Fixed
 
+- Preserve current instructions, dynamic tools, native compaction, and resumed
+  history with Pi 0.86's system-message transcript. Refresh tool declarations
+  when compaction replaces history and keep forced prompts authoritative.
+- Match Pi 0.86's reasoning Off mapping and persist transport diagnostics as
+  strict JSON. Include standalone usage entries in footer totals.
 - Show effective unified-exec yield durations beside accent-colored command
   tool titles, include explicit working directories, emphasize commands on
   their own separated rows, separate `apply_patch` results, and mute command
@@ -80,7 +93,7 @@
 
 ### Changed
 
-- Support Pi 0.85.x and update the development baseline to Pi 0.85.1.
+- Require Pi `>=0.86.0 <0.87.0` and use Pi 0.86.0 as the development baseline.
 - Describe `shell_command`, `exec_command`, and `write_stdin` in Pi's tool list,
   guidelines, and detailed tool contracts using the actual resolved default
   shell. Document command working-directory and `PI_*` context behavior,
@@ -106,9 +119,10 @@
   stderr while retaining Pi's complete-output files.
 - Replace the multi-line startup configuration dump with a concise package and
   settings-command notice, and simplify the fallback settings-save error.
-- Align deferred tool loading with Pi 0.84.3, preferring message-anchored
-  additional tools on capable Codex models while retaining tool-search and
-  top-level fallbacks.
+- Read dynamic tool declarations from Pi 0.86 system messages, preferring
+  message-anchored additional tools on capable Codex models. Use tool-search
+  pairs on other capable models and the complete top-level tool set when
+  additions are unsupported or tools are removed or redefined.
 - Simplify `apply_patch` for its queued single-writer operating model: retain
   Pi's mutation queue, remove the extension-local alias queue and
   preflight-to-execution drift machinery, use direct writes for in-place text

package/README.md

@@ -13,7 +13,7 @@ OpenAI Codex compatibility for [Pi](https://github.com/earendil-works/pi-mono),
 - **Standalone web search**: exposes Pi's dotted `web.run` tool as a native Responses namespace and executes search and browsing through Codex `alpha/search`.
 - **Dedicated Codex tool UI**: renders command tools, `apply_patch`, `image_gen.imagegen`, and `web.run` on a shared configurable surface with compact summaries and `Ctrl+O` expansion.
 - **Hosted web-search fallback**: injects native `web_search` only when `web.run` is inactive, with cached, indexed, or live modes.
-- **Native request controls**: configures Responses API text verbosity, reasoning summaries, and GPT-5.6 standard/pro reasoning mode.
+- **Native request controls**: configures Responses API text verbosity, reasoning summaries, and standard/pro reasoning mode on supported models.
 - **Session-local settings pane**: `/codex-settings` changes every compatibility setting for the current session; `Enter` persists and closes, `Escape` discards unsaved changes and closes, and `Ctrl+S` persists without closing.
 - **Session-aware footer**: shows the current Pi session ID on the first line and appends non-default Codex request modes to the model side of Pi's normal second line.
 
@@ -22,7 +22,7 @@ Pi provides the Codex OAuth flow and model catalog. At session start, this packa
 ## Requirements
 
 - Node.js 22.19 or newer
-- Pi `>=0.84.0 <0.86.0`
+- Pi `>=0.86.0 <0.87.0`
 - An OpenAI Codex login in Pi
 
 Authenticate through Pi if needed:
@@ -37,21 +37,21 @@ The compatibility baseline is official Codex CLI `0.149.1`, released August 24,
 
 ### 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.                                                                                                                                                      |
-| Command tools                                 | Replaces an active Pi `bash` tool with `exec_command` and `write_stdin`.                                                                          | Chooses unified exec or legacy shell from model metadata, platform, execution environment, and runtime capabilities.                          | `shellTool`: `unified_exec` or `shell_command`.                                                                                                                             |
-| `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.                                                                                                                                                 |
-| `apply_patch` diagnostics capture             | Disabled; no separate request or filesystem snapshot artifacts are retained.                                                                      | Codex owns its rollout diagnostics rather than writing this package's artifact format.                                                        | `applyPatchDiagnostics`: 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`.                                                                                                                   |
+| 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.                                                                                                                                                      |
+| Command tools                                 | Replaces an active Pi `bash` tool with `exec_command` and `write_stdin`.                                                                  | Chooses unified exec or legacy shell from model metadata, platform, execution environment, and runtime capabilities.                          | `shellTool`: `unified_exec` or `shell_command`.                                                                                                                             |
+| `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.                                                                                                                                                 |
+| `apply_patch` diagnostics capture             | Disabled; no separate request or filesystem snapshot artifacts are retained.                                                              | Codex owns its rollout diagnostics rather than writing this package's artifact format.                                                        | `applyPatchDiagnostics`: 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 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 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.
 
@@ -62,7 +62,8 @@ The compatibility baseline is official Codex CLI `0.149.1`, released August 24,
 | Session storage             | Pi remains the canonical session owner. Opaque Codex compaction checkpoints are stored in Pi `compaction` entries, and otherwise lossy Responses output is stored in sparse custom native-response entries. Official Codex owns a rollout/thread store directly.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | Branching                   | Checkpoints and native response overrides follow Pi's active session branch. Official Codex uses its own thread, turn, rollback, fork, and context-window lineage.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | Model switching             | This package rejects model switches while the active Pi branch contains a native Codex checkpoint because the checkpoint is model-specific.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| System instructions         | Replay Pi's system-message sections into the complete current prompt. Responses Lite models prepend it as developer input after `additional_tools`; other models send it through Responses `instructions`. Do not replay older Pi system-prompt text alongside that current prompt. `/reload`, forced prompts, compaction snapshots, and resumed sessions use the current state without rewriting old checkpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| Dynamic tool declarations   | Replay additive `toolsAdded` system messages in place as `additional_tools` or tool-search pairs on capable models. Tool removal or redefinition uses the complete current top-level tool set instead. Compaction rebases declarations so tools remain available after their history is replaced.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | 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 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.                                                                                                                                                                                                                                                                                                                                                                                                                           |
@@ -198,7 +199,7 @@ Defaults:
 | Setting                 | Values                                               | Default        | Behavior                                                                                                                                                                                                                                  |
 | ----------------------- | ---------------------------------------------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `fastMode`              | boolean                                              | `false`        | Adds `service_tier: "priority"` to requests while retaining the current `openai-codex` provider and model.                                                                                                                                |
-| `responsesLite`         | boolean                                              | `false`        | Uses Codex's Responses Lite input envelope on supported GPT-5.6 models when enabled. By default, those models use ordinary Responses instructions and tools.                                                                              |
+| `responsesLite`         | boolean                                              | `false`        | Uses Codex's Responses Lite input envelope on supported models when enabled. By default, those models use ordinary Responses instructions and tools.                                                                                      |
 | `toolBackground`        | `subtle`, `status`, `none`                           | `subtle`       | Controls the shared self-rendered background for command tools, `apply_patch`, `image_gen.imagegen`, and `web.run`. `status` uses Pi's pending/success/error backgrounds; `none` keeps the custom layout transparent.                     |
 | `shellTool`             | `unified_exec`, `shell_command`                      | `unified_exec` | Selects the command surface on `openai-codex` models. The selected Codex command surface replaces Pi `bash` only when `bash` was active.                                                                                                  |
 | `applyPatch`            | boolean                                              | `true`         | On selected `openai-codex` models, uses the extension's `apply_patch` tool instead of Pi's active `edit` and `write` tools. Other providers always use their normal Pi tool set.                                                          |
@@ -211,7 +212,12 @@ Defaults:
 | `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.                                                                                                                                                    |
-| `reasoningMode`         | `standard`, `pro`                                    | `standard`     | Controls GPT-5.6 execution mode independently of Pi's reasoning-effort control. The default omits `reasoning.mode`; `pro` sends `reasoning.mode: "pro"`.                                                                                  |
+| `reasoningMode`         | `standard`, `pro`                                    | `standard`     | Controls supported models' execution mode independently of Pi's reasoning-effort control. The default omits `reasoning.mode`; `pro` sends `reasoning.mode: "pro"`.                                                                        |
+
+Responses Lite supports exactly `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`,
+and `gpt-6-astra`. Pro reasoning mode supports `gpt-5.6`, `gpt-5.6-*`, and
+exactly `gpt-6-astra`. Both controls remain opt-in; other GPT-6 model IDs are
+not included.
 
 Invalid JSON setting values are ignored and invalid JSON does not prevent Pi from starting. The settings pane never writes on ordinary changes, refuses to overwrite invalid JSON when `Enter` or `Ctrl+S` attempts to save, and retains unknown keys when saving. Project configuration is read only when the project is trusted.
 
@@ -306,6 +312,12 @@ permissions.
 
 ## Native compaction
 
+See the [Codex compaction approach review](CODEX_COMPACTION_APPROACH_REVIEW.md)
+for a focused `0.153.4` source review, including experimental notes/history
+recovery and unsummarized context resets, implementation options, and trade-offs.
+That proposal does not change this package's runtime or its package-wide
+compatibility baseline.
+
 The extension handles native compaction for `openai-codex`. It follows the Codex v2 flow:
 
 1. Send normal Responses history followed by `{ "type": "compaction_trigger" }`.
@@ -313,7 +325,7 @@ The extension handles native compaction for `openai-codex`. It follows the Codex
 3. Retain approximately 64,000 tokens of recent user, developer, and system context.
 4. Persist the opaque checkpoint in the Pi session and replay it on later requests.
 
-Ordinary responses and compaction use the same extension-managed SSE/WebSocket transport. Before the first WebSocket turn for a session and model, the provider performs a best-effort v2 `generate: false` prewarm of the static instruction/tool prefix, then generates the dynamic conversation input from its continuation. With `responsesLite: false`, supported GPT-5.6 models use the ordinary Responses envelope and receive their own ordinary-prefix prewarm.
+Ordinary responses and compaction use the same extension-managed SSE/WebSocket transport. Before the first WebSocket turn for a session and model, the provider performs a best-effort v2 `generate: false` prewarm of the static instruction/tool prefix, then generates the dynamic conversation input from its continuation. With `responsesLite: false`, supported models use the ordinary Responses envelope and receive their own ordinary-prefix prewarm.
 
 Healthy session WebSockets remain available until the server closes them or Pi tears down the session. Retryable WebSocket failures before model-visible output receive up to five fresh-connection retries before the session switches to sticky SSE. Retryable SSE HTTP failures and dropped streams receive up to five same-request resampling attempts before model-visible output. Both transports use Codex-style exponential backoff with ±10% jitter and preserve the same prompt-cache, session, account, installation, and window identities. Server metadata is not considered model-visible output, so a routing-state-only response can still be retried safely. Transport failures after model-visible output fail closed rather than risk duplicate text or tool calls. Explicit retryable `response.failed`/`response.incomplete` protocol terminals instead return to the provider-owned sampling loop, which preserves completed output items as the next request's history.
 
@@ -467,6 +479,23 @@ cannot be inspected, it says that the final state was not verified.
 The complete feedback and rendering contract is documented in
 [`APPLY_PATCH_INSTRUCTION_FEEDBACK.md`](APPLY_PATCH_INSTRUCTION_FEEDBACK.md).
 
+### `pi-apply-patch` command line
+
+The package installs a `pi-apply-patch` executable for use outside Pi sessions:
+
+```bash
+pi-apply-patch parse patch.txt
+cat patch.txt | pi-apply-patch parse
+```
+
+`parse` runs the same parser as the tool and prints `{ operations, environmentId? }` as JSON.
+Each operation is `add` with `content`, `delete`, or `update` with `chunks` and an optional
+`moveTo`. It does not read or write any other file. Exit status is `0` when parsed, `1` for an
+invalid patch, and `2` for a usage or read error.
+
+The command line does not apply patches. Applying through a standalone process would bypass Pi's
+file mutation queue and the tool-result contract, so applying stays inside the `apply_patch` tool.
+
 ## `image_gen.imagegen`
 
 The package registers the dotted Pi tool name `image_gen.imagegen` and serializes it as a native Responses API namespace:
@@ -537,8 +566,7 @@ Both namespace tools are accepted only from the fixed extension-owned allowlist.
 mise trust
 mise install
 npm install
-npm run check
-npm test
+mise run check
 npm run pack:dry
 ```
 

package/THIRD_PARTY_NOTICES.md

@@ -12,7 +12,7 @@ Source: <https://github.com/openai/codex>
 
 ## Pi AI
 
-Selected OpenAI Codex transport, Responses stream processing, and history serialization methods are adapted from `@earendil-works/pi-ai`.
+Selected OpenAI Codex transport, Responses stream processing, and history serialization methods are adapted from `@earendil-works/pi-ai`. History serialization follows the Pi 0.86.0 transcript contract.
 
 Pi AI, Copyright (c) 2025 Mario Zechner
 

package/bin/pi-apply-patch.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { text } from "node:stream/consumers";
+import { runApplyPatchCli } from "../extensions/openai-codex-compat/apply-patch-cli.ts";
+
+process.exitCode = await runApplyPatchCli(process.argv.slice(2), {
+  readStdin: () => text(process.stdin),
+  writeStdout: (content) => {
+    process.stdout.write(content);
+  },
+  writeStderr: (content) => {
+    process.stderr.write(content);
+  },
+});

package/extensions/openai-codex-compat/apply-patch-cli.ts

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import type { ParsedPatch } from "./apply-patch-engine.ts";
+import { ApplyPatchParseError, parsePatchDocument } from "./apply-patch-engine.ts";
+import { errorMessage } from "./apply-patch-engine/apply-patch-engine-errors.ts";
+
+export const APPLY_PATCH_CLI_NAME = "pi-apply-patch";
+
+export const APPLY_PATCH_CLI_USAGE = `Usage: ${APPLY_PATCH_CLI_NAME} parse [<file>]
+
+Parse a Codex apply_patch document and print its operations as JSON.
+Reads <file>, or standard input when <file> is omitted or "-".
+
+Exit status: 0 parsed, 1 invalid patch, 2 usage error.
+`;
+
+export type ApplyPatchCliIo = {
+  readStdin: () => Promise<string>;
+  writeStdout: (text: string) => void;
+  writeStderr: (text: string) => void;
+};
+
+export type ApplyPatchCliParseOutput = Pick<ParsedPatch, "operations" | "environmentId">;
+
+export function applyPatchCliParseOutput(parsed: ParsedPatch): ApplyPatchCliParseOutput {
+  return parsed.environmentId === undefined
+    ? { operations: parsed.operations }
+    : { environmentId: parsed.environmentId, operations: parsed.operations };
+}
+
+export async function runApplyPatchCli(
+  argv: readonly string[],
+  io: ApplyPatchCliIo,
+): Promise<number> {
+  const [command, ...rest] = argv;
+  if (command === undefined || command === "--help" || command === "-h") {
+    io.writeStdout(APPLY_PATCH_CLI_USAGE);
+    return command === undefined ? 2 : 0;
+  }
+  if (command !== "parse" || rest.length > 1) {
+    io.writeStderr(APPLY_PATCH_CLI_USAGE);
+    return 2;
+  }
+
+  const source = rest[0];
+  let patch: string;
+  try {
+    patch =
+      source === undefined || source === "-"
+        ? await io.readStdin()
+        : await readFile(source, "utf8");
+  } catch (error) {
+    io.writeStderr(`${APPLY_PATCH_CLI_NAME}: cannot read patch: ${errorMessage(error)}\n`);
+    return 2;
+  }
+
+  try {
+    const output = applyPatchCliParseOutput(parsePatchDocument(patch));
+    io.writeStdout(`${JSON.stringify(output, null, 2)}\n`);
+    return 0;
+  } catch (error) {
+    if (!(error instanceof ApplyPatchParseError)) throw error;
+    io.writeStderr(`${APPLY_PATCH_CLI_NAME}: ${error.message}\n`);
+    return 1;
+  }
+}

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

@@ -2,6 +2,8 @@ import { isBoolean, isNonNullObject, isNumber, isString } from "./value-contract
 import {
   calculateCost,
   type Api,
+  type JsonObject as PiJsonObject,
+  type JsonValue as PiJsonValue,
   type Model,
   type ProviderHeaders,
   type Usage,
@@ -69,7 +71,6 @@ export interface JsonRecord {
   name?: JsonValue;
   arguments?: JsonValue;
   toolCallId?: JsonValue;
-  addedToolNames?: JsonValue;
   kind?: JsonValue;
   version?: JsonValue;
   modelId?: JsonValue;
@@ -105,6 +106,20 @@ export function requireJsonRecord(value: unknown, label = "value"): JsonRecord {
   return value;
 }
 
+/** Omit optional wire fields before persisting diagnostics in Pi's strict JSON data. */
+export function toPiJsonObject(value: JsonRecord): PiJsonObject {
+  const result: PiJsonObject = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== undefined) result[key] = toPiJsonValue(entry);
+  }
+  return result;
+}
+
+function toPiJsonValue(value: JsonValue): PiJsonValue {
+  if (Array.isArray(value)) return value.map(toPiJsonValue);
+  return isObject(value) ? toPiJsonObject(value) : value;
+}
+
 export function optionalJsonRecord(value: unknown, label = "value"): JsonRecord | undefined {
   return value === undefined ? undefined : requireJsonRecord(value, label);
 }

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

@@ -1,43 +1,11 @@
 import type { SessionEntry, ToolInfo } from "@earendil-works/pi-coding-agent";
-import type { Api, Context, Model, Tool } from "@earendil-works/pi-ai";
+import type { Api, Model } from "@earendil-works/pi-ai";
 import { providerHistory, type GrammarToolInputProperties } from "../compaction-checkpoint.ts";
 import type { ImageDetail } from "../config.ts";
 import { normalizeReplayItem, stableResponsesJson } from "../responses-replay.ts";
 import type { ResponsesInputItem, ResponsesOutputItem } from "../responses-item-schema.ts";
 import type { ResponsesItem as SerializedResponsesItem } from "../vendor/pi-ai/openai-responses-serialization.ts";
 
-export interface DeferredToolGroups {
-  immediate: Tool[];
-  deferred: Map<string, Tool>;
-}
-
-export function splitDeferredTools(context: Context, enabled: boolean): DeferredToolGroups {
-  const unique = new Map((context.tools ?? []).map((tool) => [tool.name, tool]));
-  if (!enabled) return { immediate: [...unique.values()], deferred: new Map() };
-
-  const deferredNames = new Set<string>();
-  const usedNames = new Set<string>();
-  for (const message of context.messages) {
-    if (message.role === "assistant") {
-      for (const block of message.content) {
-        if (block.type === "toolCall") usedNames.add(block.name);
-      }
-    } else if (message.role === "toolResult") {
-      for (const name of message.addedToolNames ?? []) {
-        if (!usedNames.has(name)) deferredNames.add(name);
-      }
-    }
-  }
-
-  const immediate: Tool[] = [];
-  const deferred = new Map<string, Tool>();
-  for (const [name, tool] of unique) {
-    if (deferredNames.has(name)) deferred.set(name, tool);
-    else immediate.push(tool);
-  }
-  return { immediate, deferred };
-}
-
 export function nativeOverrideRequired(
   rawItems: readonly ResponsesOutputItem[],
   canonicalItems: readonly SerializedResponsesItem[],
@@ -91,6 +59,7 @@ export function splitUnsampledUserInput(options: {
     allTools: options.allTools,
     grammarToolInputProperties: options.grammarToolInputProperties,
     imageDetail: options.imageDetail,
+    anchorsToolAdditions: false,
   });
   if (encoded.length === 0 || encoded.length > options.history.length) return { kind: "unsafe" };
 

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

@@ -4,6 +4,7 @@ import type {
   AssistantMessage,
   AssistantMessageDiagnostic,
   Context,
+  JsonObject,
   Model,
   OpenAICodexResponsesOptions,
   Usage,
@@ -57,7 +58,7 @@ export function assessAttemptToolCalls(
 }
 
 export interface OutputItemTypeCounts {
-  [type: string]: number | undefined;
+  [type: string]: number;
 }
 
 export function outputItemTypeCounts(items: readonly ResponsesOutputItem[]): OutputItemTypeCounts {
@@ -91,7 +92,7 @@ export function responseDecisionDiagnostic(options: {
     options.capture.streamedToolCallIndexes.size > 0;
   if (!nontrivial) return undefined;
 
-  const details: JsonRecord = {
+  const details: JsonObject = {
     attempt: options.attempt,
     terminalType: options.failureReason ?? options.terminalState?.type ?? "missing",
     outputItemTypes: outputItemTypeCounts(options.attemptItems),

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

@@ -5,6 +5,10 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   clampThinkingLevel,
   createAssistantMessageEventStream,
+  getCurrentSystemPrompt,
+  getDeclaredTools,
+  normalizeContext,
+  resolveTranscriptTools,
   type Api,
   type AssistantMessage,
   type AssistantMessageEventStream,
@@ -13,6 +17,7 @@ import {
   type OpenAICodexResponsesOptions,
   type Provider,
   type SimpleStreamOptions,
+  type TranscriptContext,
   type Usage,
   uuidv7,
 } from "@earendil-works/pi-ai";
@@ -26,7 +31,6 @@ import {
   providerHistory,
   remoteCompactionMarkerSummary,
   responsesCompatibility,
-  responsesDeferredToolsMode,
   searchCheckpoint,
   type CheckpointData,
   type CompactionDecision,
@@ -38,6 +42,7 @@ import {
   isObject,
   remoteCompactionPayload,
   requireResponsesInputItems,
+  toPiJsonObject,
   withoutConversationInput,
   type JsonRecord,
   type JsonValue,
@@ -115,7 +120,6 @@ function codexStreamOptions(value: unknown): OpenAICodexResponsesOptions | undef
 }
 import {
   nativeOverrideRequired,
-  splitDeferredTools,
   splitUnsampledUserInput,
   userEntryAfterLastSampled,
 } from "./codex-provider-history.ts";
@@ -156,7 +160,7 @@ type CodexCompactionResult = { checkpoint: CheckpointData; usage?: Usage };
 
 type BuildRequestBodyOptions = {
   model: Model<Api>;
-  context: Context;
+  context: TranscriptContext;
   requestOptions: OpenAICodexResponsesOptions;
   runtimeSessionId: string | undefined;
   cacheSessionId: string | undefined;
@@ -488,19 +492,22 @@ export class CodexProviderRuntime {
 
   private wireHistory(
     model: Model<Api>,
-    context: Context,
+    context: TranscriptContext,
     grammarToolInputProperties: GrammarToolInputProperties,
     sessionId: string | undefined,
+    anchorsToolAdditions: boolean,
   ): ResponsesInputItem[] {
     const scope = sessionId ? this.scopes.get(sessionId) : undefined;
+    const compat = responsesCompatibility(model.compat);
     if (!scope) {
-      const compat = responsesCompatibility(model.compat);
-      const deferredToolsMode = responsesDeferredToolsMode(compat);
       const nativeItems = new Map<string, ResponsesOutputItem[]>();
       const serializationOptions: NonNullable<Parameters<typeof convertResponsesMessages>[3]> = {
         includeSystemPrompt: false,
+        includeSystemUpdates: false,
+        supportsMidConvoSystemMessages: true,
+        supportsAdditionalTools: anchorsToolAdditions && (compat.supportsAdditionalTools ?? false),
+        supportsToolSearch: anchorsToolAdditions && (compat.supportsToolSearch ?? false),
         grammarToolInputProperties,
-        deferredTools: splitDeferredTools(context, deferredToolsMode !== undefined).deferred,
         toolOptions: {
           strict: false,
           supportsStrictMode: compat.supportsStrictMode ?? true,
@@ -511,7 +518,6 @@ export class CodexProviderRuntime {
         toolResultImageDetail: "auto",
         nativeAssistantItems: nativeItems,
       };
-      if (deferredToolsMode) serializationOptions.deferredToolsMode = deferredToolsMode;
       return requireResponsesInputItems(
         convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, serializationOptions),
       );
@@ -522,6 +528,7 @@ export class CodexProviderRuntime {
       allTools: this.pi.getAllTools(),
       grammarToolInputProperties,
       imageDetail: scope.config.imageDetail,
+      anchorsToolAdditions,
     });
   }
 
@@ -536,14 +543,39 @@ export class CodexProviderRuntime {
       turnId,
     } = options;
     const compat = responsesCompatibility(model.compat);
-    const deferredToolsMode = responsesDeferredToolsMode(compat);
-    const toolPlacement = splitDeferredTools(context, deferredToolsMode !== undefined);
+    const scope = runtimeSessionId ? this.scopes.get(runtimeSessionId) : undefined;
+    const threshold = scope?.config.autoCompactAtPercent;
+    // Percentage compaction drops historical tool additions. Rebase declarations
+    // before serialization so both the compaction and its continuation stay valid.
+    const compactionPending =
+      threshold !== undefined &&
+      scope?.contextPercent !== null &&
+      scope?.contextPercent !== undefined &&
+      scope.contextPercent >= threshold;
+    const toolPlacement = resolveTranscriptTools(
+      context.messages,
+      !compactionPending &&
+        ((compat.supportsAdditionalTools ?? false) || (compat.supportsToolSearch ?? false)),
+    );
+    // A forced prompt can project all tools into a single leading system message.
+    // Do not replay additions from the stored branch after that projection.
+    const anchorsToolAdditions =
+      toolPlacement.anchorsAdditions &&
+      context.messages
+        .slice(1)
+        .some((message) => message.role === "system" && (message.toolsAdded?.length ?? 0) > 0);
     let body: JsonRecord = {
       model: model.id,
       store: false,
       stream: true,
-      instructions: context.systemPrompt || "You are a helpful assistant.",
-      input: this.wireHistory(model, context, grammarToolInputProperties, runtimeSessionId),
+      instructions: getCurrentSystemPrompt(context.messages) || "You are a helpful assistant.",
+      input: this.wireHistory(
+        model,
+        context,
+        grammarToolInputProperties,
+        runtimeSessionId,
+        anchorsToolAdditions,
+      ),
       text: { verbosity: requestOptions.textVerbosity ?? "low" },
       include: ["reasoning.encrypted_content"],
       tool_choice: requestOptions.toolChoice ?? "auto",
@@ -562,8 +594,8 @@ export class CodexProviderRuntime {
       ),
     });
     if (requestOptions.serviceTier !== undefined) body.service_tier = requestOptions.serviceTier;
-    if (toolPlacement.immediate.length > 0) {
-      body.tools = convertResponsesTools(toolPlacement.immediate, {
+    if (toolPlacement.requestTools.length > 0) {
+      body.tools = convertResponsesTools(toolPlacement.requestTools, {
         strict: false,
         supportsStrictMode: compat.supportsStrictMode ?? true,
         supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools ?? false,
@@ -573,7 +605,9 @@ export class CodexProviderRuntime {
     if (requestOptions.reasoningEffort !== undefined) {
       const mapped =
         requestOptions.reasoningEffort === "none"
-          ? (model.thinkingLevelMap?.off ?? "none")
+          ? model.thinkingLevelMap?.off === undefined
+            ? "none"
+            : model.thinkingLevelMap.off
           : (model.thinkingLevelMap?.[requestOptions.reasoningEffort] ??
             requestOptions.reasoningEffort);
       if (mapped !== null) {
@@ -582,6 +616,8 @@ export class CodexProviderRuntime {
           summary: requestOptions.reasoningSummary ?? "auto",
         };
       }
+    } else if (model.reasoning && model.thinkingLevelMap?.off !== null) {
+      body["reasoning"] = { effort: model.thinkingLevelMap?.off ?? "none" };
     }
     return body;
   }
@@ -682,7 +718,7 @@ export class CodexProviderRuntime {
 
   private async maybeCompactPercentage(
     model: Model<Api>,
-    context: Context,
+    context: TranscriptContext,
     options: OpenAICodexResponsesOptions,
     body: JsonRecord,
     grammarToolInputProperties: GrammarToolInputProperties,
@@ -742,7 +778,7 @@ export class CodexProviderRuntime {
       template: withoutConversationInput(body),
       instructions: isString(body.instructions)
         ? body.instructions
-        : context.systemPrompt || "You are a helpful assistant.",
+        : getCurrentSystemPrompt(context.messages) || "You are a helpful assistant.",
       grammarToolInputProperties,
       priority: scope.config.fastMode,
       compactionMetadata: responsesCompactionV2Metadata("auto", "context_limit", "pre_turn"),
@@ -781,9 +817,10 @@ export class CodexProviderRuntime {
 
   stream(
     model: Model<Api>,
-    context: Context,
+    input: Context,
     options?: OpenAICodexResponsesOptions,
   ): AssistantMessageEventStream {
+    const context = normalizeContext(input);
     const stream = createAssistantMessageEventStream();
     const requestOptions = transportOptions(options);
     const output: AssistantMessage = {
@@ -828,7 +865,7 @@ export class CodexProviderRuntime {
         );
       }
       const grammarToolInputProperties = createGrammarToolInputProperties(
-        context.tools,
+        getDeclaredTools(context.messages),
         responsesCompatibility(model.compat).supportsOpenAIGrammarTools ?? false,
       );
       let body = this.buildRequestBody({
@@ -903,7 +940,12 @@ export class CodexProviderRuntime {
         turnState: agentTurn.turnState,
         cacheDiagnostics,
       });
-      if (prewarmDiagnostics.length > 0) output.diagnostics = prewarmDiagnostics;
+      if (prewarmDiagnostics.length > 0) {
+        output.diagnostics = prewarmDiagnostics.map((diagnostic) => ({
+          ...diagnostic,
+          details: toPiJsonObject(diagnostic.details),
+        }));
+      }
       let continuationHandle: CodexContinuationHandle | undefined;
       let webSocketResponseHandle: CodexWebSocketResponseHandle | undefined;
       let startEmitted = false;
@@ -926,7 +968,10 @@ export class CodexProviderRuntime {
         },
         onTransportStart: emitStart,
         onTransportDiagnostic(diagnostic: CodexTransportDiagnostic) {
-          output.diagnostics = [...(output.diagnostics ?? []), diagnostic];
+          output.diagnostics = [
+            ...(output.diagnostics ?? []),
+            { ...diagnostic, details: toPiJsonObject(diagnostic.details) },
+          ];
         },
       };
       let responseRequests = 0;
@@ -1153,12 +1198,9 @@ export class CodexProviderRuntime {
       const canonicalContext: Context = {
         messages: [output],
       };
-      if (context.tools) canonicalContext.tools = context.tools;
-      const deferredToolsMode = responsesDeferredToolsMode(compat);
       const serializationOptions: NonNullable<Parameters<typeof convertResponsesMessages>[3]> = {
         includeSystemPrompt: false,
         grammarToolInputProperties,
-        deferredTools: splitDeferredTools(context, deferredToolsMode !== undefined).deferred,
         toolOptions: {
           strict: false,
           supportsStrictMode: compat.supportsStrictMode ?? true,
@@ -1170,7 +1212,6 @@ export class CodexProviderRuntime {
           (runtimeSessionId ? this.scopes.get(runtimeSessionId)?.config.imageDetail : undefined) ??
           "auto",
       };
-      if (deferredToolsMode) serializationOptions.deferredToolsMode = deferredToolsMode;
       const canonicalItems = convertResponsesMessages(
         model,
         canonicalContext,

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

@@ -5,7 +5,7 @@ import type {
 } from "@earendil-works/pi-ai";
 import type { CodexCacheDiagnosticContext } from "../codex-cache-diagnostics.ts";
 import type { CodexRequestKind } from "../codex-metadata.ts";
-import type { JsonRecord } from "../codex-protocol.ts";
+import type { JsonRecord, JsonValue } from "../codex-protocol.ts";
 import type { CodexTurnState } from "./codex-transport-turn-state.ts";
 
 export type CodexJsonRequestOptions = {
@@ -43,8 +43,8 @@ export type CodexContinuationHistoryMismatch = {
   index: number;
   baselineInputItems: number;
   currentInputItems: number;
-  baselineItem?: unknown;
-  currentItem?: unknown;
+  baselineItem?: JsonValue;
+  currentItem?: JsonValue;
 };
 
 export type CodexTransportRecoveryAttempt = {

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

@@ -75,11 +75,11 @@ export function cachedRequestBody(entry: CachedWebSocket, body: JsonRecord): Cac
       index: mismatchIndex,
       baselineInputItems: baseline.length,
       currentInputItems: currentInput.length,
-      baselineItem: structuredClone(baseline[mismatchIndex]),
     };
-    if (mismatchIndex < currentInput.length) {
-      historyMismatch.currentItem = structuredClone(currentInput[mismatchIndex]);
-    }
+    const baselineItem = baseline[mismatchIndex];
+    const currentItem = currentInput[mismatchIndex];
+    if (baselineItem !== undefined) historyMismatch.baselineItem = structuredClone(baselineItem);
+    if (currentItem !== undefined) historyMismatch.currentItem = structuredClone(currentItem);
     return {
       body,
       contextMode: "full",

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

@@ -7,7 +7,7 @@ import {
   type SessionEntry,
   type ToolInfo,
 } from "@earendil-works/pi-coding-agent";
-import type { Api, Message, Model, Tool } from "@earendil-works/pi-ai";
+import type { Api, Message, Model, SystemMessage } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
 import { APPLY_PATCH_LARK_GRAMMAR, APPLY_PATCH_TOOL_NAME } from "./apply-patch.ts";
 import { CODEX_TOOL_CALL_PROVIDERS } from "./codex-identifiers.ts";
@@ -32,10 +32,7 @@ import {
   type ResponsesOutputItem,
 } from "./responses-item-schema.ts";
 import type { ResponsesToolDefinition } from "./responses-tool-schema.ts";
-import {
-  convertResponsesMessages,
-  type DeferredToolsMode,
-} from "./vendor/pi-ai/openai-responses-serialization.ts";
+import { convertResponsesMessages } from "./vendor/pi-ai/openai-responses-serialization.ts";
 
 export const CHECKPOINT_ENTRY_TYPE = "openai-codex-compat-remote-compaction";
 export const CHECKPOINT_FORMAT_VERSION = 1;
@@ -85,14 +82,6 @@ export function responsesCompatibility(value: unknown): ResponsesCompatibility {
   return compatibility;
 }
 
-export function responsesDeferredToolsMode(
-  compatibility: ResponsesCompatibility,
-): DeferredToolsMode | undefined {
-  if (compatibility.supportsAdditionalTools) return "additional-tools";
-  if (compatibility.supportsToolSearch) return "tool-search";
-  return undefined;
-}
-
 function responsesToolParameters(tool: ToolInfo): JsonRecord {
   if (!isObject(tool.parameters)) {
     throw new Error(`Tool ${tool.name} must have JSON object parameters.`);
@@ -164,6 +153,7 @@ type EncodeMessagesOptions = {
   allTools: readonly ToolInfo[];
   grammarToolInputProperties: GrammarToolInputProperties;
   imageDetail: ImageDetail;
+  anchorsToolAdditions?: boolean;
   nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesOutputItem[]>;
 };
 
@@ -174,40 +164,24 @@ export type EncodeSessionEntriesOptions = {
   grammarToolInputProperties?: GrammarToolInputProperties;
   imageDetail?: ImageDetail;
   nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesOutputItem[]>;
+  initialSystemMessage?: SystemMessage;
+  anchorsToolAdditions?: boolean;
 };
 
-function asPiTool(tool: ToolInfo, grammarToolInputProperties: GrammarToolInputProperties): Tool {
-  const piTool: Tool = {
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters,
-  };
-  if (tool.name === APPLY_PATCH_TOOL_NAME && grammarToolInputProperties.has(tool.name)) {
-    piTool.constrainedSampling = {
-      type: "grammar",
-      variants: { openai_lark: APPLY_PATCH_LARK_GRAMMAR },
-    };
-  }
-  return piTool;
-}
-
 /** Encode Pi's canonical messages using Pi AI's OpenAI Responses serializer. */
 function encodeMessages(options: EncodeMessagesOptions): ResponsesInputItem[] {
-  const {
-    model,
-    messages,
-    allTools,
-    grammarToolInputProperties,
-    imageDetail,
-    nativeAssistantItems,
-  } = options;
-  const tools = allTools.map((tool) => asPiTool(tool, grammarToolInputProperties));
+  const { model, messages, grammarToolInputProperties, imageDetail, nativeAssistantItems } =
+    options;
   const compat = responsesCompatibility(model.compat);
-  const deferredToolsMode = responsesDeferredToolsMode(compat);
   const serializationOptions: NonNullable<Parameters<typeof convertResponsesMessages>[3]> = {
     includeSystemPrompt: false,
+    includeSystemUpdates: false,
+    supportsMidConvoSystemMessages: true,
+    supportsAdditionalTools:
+      options.anchorsToolAdditions !== false && (compat.supportsAdditionalTools ?? false),
+    supportsToolSearch:
+      options.anchorsToolAdditions !== false && (compat.supportsToolSearch ?? false),
     grammarToolInputProperties,
-    deferredTools: new Map(tools.map((tool) => [tool.name, tool])),
     toolOptions: {
       strict: false,
       supportsStrictMode: compat?.supportsStrictMode ?? true,
@@ -217,17 +191,11 @@ function encodeMessages(options: EncodeMessagesOptions): ResponsesInputItem[] {
     textContentItemToolResultNames: CODEX_TEXT_CONTENT_ITEM_TOOL_RESULT_NAMES,
     toolResultImageDetail: imageDetail,
   };
-  if (deferredToolsMode) serializationOptions.deferredToolsMode = deferredToolsMode;
   if (nativeAssistantItems) {
     serializationOptions.nativeAssistantItems = nativeAssistantItems;
   }
   return requireResponsesInputItems(
-    convertResponsesMessages(
-      model,
-      { messages, tools },
-      CODEX_TOOL_CALL_PROVIDERS,
-      serializationOptions,
-    ),
+    convertResponsesMessages(model, { messages }, CODEX_TOOL_CALL_PROVIDERS, serializationOptions),
   );
 }
 
@@ -243,11 +211,19 @@ export function encodeSessionEntries(options: EncodeSessionEntriesOptions): Resp
   const messages = entries.flatMap((entry) => sessionEntryToContextMessages(entry));
   const encodeOptions: EncodeMessagesOptions = {
     model,
-    messages: convertToLlm(messages),
+    // A partial tail can start with a system update. Seed its prior state so
+    // the serializer does not mistake that update for the leading declaration.
+    messages: [
+      options.initialSystemMessage ?? { role: "system", content: "", timestamp: 0 },
+      ...convertToLlm(messages),
+    ],
     allTools,
     grammarToolInputProperties,
     imageDetail,
   };
+  if (options.anchorsToolAdditions !== undefined) {
+    encodeOptions.anchorsToolAdditions = options.anchorsToolAdditions;
+  }
   if (nativeAssistantItems) encodeOptions.nativeAssistantItems = nativeAssistantItems;
   return encodeMessages(encodeOptions);
 }
@@ -371,6 +347,7 @@ export function providerHistory(options: {
   grammarToolInputProperties?: GrammarToolInputProperties;
   imageDetail?: ImageDetail;
   recoverLatestOverflowPrefix?: boolean;
+  anchorsToolAdditions?: boolean;
 }): ResponsesInputItem[] {
   const branch = [...options.branch];
   let recoveredPrefix: ResponsesInputItem[] = [];
@@ -407,6 +384,9 @@ export function providerHistory(options: {
         `The latest Codex compaction checkpoint belongs to ${checkpoint.data.modelId}, not ${options.wireModel.id}.`,
       );
     }
+    const checkpointEntry = branch[checkpoint.entryIndex];
+    const initialSystemMessage =
+      checkpointEntry?.type === "compaction" ? checkpointEntry.systemMessage : undefined;
     return [
       ...checkpoint.data.history.map((item) => structuredClone(item)),
       ...encodeSessionEntries({
@@ -416,6 +396,10 @@ export function providerHistory(options: {
         grammarToolInputProperties: options.grammarToolInputProperties ?? new Map(),
         imageDetail: options.imageDetail ?? "auto",
         nativeAssistantItems,
+        ...(initialSystemMessage ? { initialSystemMessage } : {}),
+        ...(options.anchorsToolAdditions === undefined
+          ? {}
+          : { anchorsToolAdditions: options.anchorsToolAdditions }),
       }),
       ...recoveredPrefix,
     ];
@@ -430,6 +414,9 @@ export function providerHistory(options: {
       grammarToolInputProperties: options.grammarToolInputProperties ?? new Map(),
       imageDetail: options.imageDetail ?? "auto",
       nativeAssistantItems,
+      ...(options.anchorsToolAdditions === undefined
+        ? {}
+        : { anchorsToolAdditions: options.anchorsToolAdditions }),
     }),
     ...recoveredPrefix,
   ];

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

@@ -158,7 +158,10 @@ function aggregateFooterEntries(entries: readonly SessionEntry[]): SessionEntry[
       entry.message.usage
     ) {
       addUsage(precedingUsage, entry.message.usage);
-    } else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+    } else if (
+      (entry.type === "usage" || entry.type === "branch_summary" || entry.type === "compaction") &&
+      entry.usage
+    ) {
       addUsage(precedingUsage, entry.usage);
     }
   }

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

@@ -249,17 +249,13 @@ export default function registerRemoteCompaction(
         grammarToolInputProperties,
         imageDetail: config.imageDetail,
         recoverLatestOverflowPrefix: event.reason === "overflow" && event.willRetry,
+        anchorsToolAdditions: false,
       });
-      let template = matching?.payload;
-      if (!template) {
-        template = {};
-        const tools = activeResponsesTools(
-          allTools,
-          pi.getActiveTools(),
-          grammarToolInputProperties,
-        );
-        if (tools) template.tools = tools;
-      }
+      // A cached turn template can contain only the initial declarations.
+      // Compaction rebases history, so use the complete current tool set.
+      const template: JsonRecord = { ...matching?.payload };
+      template.tools =
+        activeResponsesTools(allTools, pi.getActiveTools(), grammarToolInputProperties) ?? [];
       const requestOptions: OpenAICodexResponsesOptions = {
         ...matching?.requestOptions,
         apiKey: authentication.apiKey,

package/extensions/openai-codex-compat/request-options.ts

@@ -20,7 +20,7 @@ export function isCodexModel(model: Model<Api> | undefined): model is Model<type
 }
 
 export function supportsReasoningMode(modelId: string): boolean {
-  return /^gpt-5\.6(?:-|$)/.test(modelId);
+  return modelId === "gpt-6-astra" || /^gpt-5\.6(?:-|$)/.test(modelId);
 }
 
 function isWebSearchTool(value: unknown): boolean {

package/extensions/openai-codex-compat/responses-lite.ts

@@ -9,6 +9,7 @@ const RESPONSES_LITE_MODELS: ReadonlySet<string> = new Set([
   "gpt-5.6-sol",
   "gpt-5.6-terra",
   "gpt-5.6-luna",
+  "gpt-6-astra",
 ]);
 
 function isHostedTool(tool: JsonRecord): boolean {

package/extensions/openai-codex-compat/vendor/pi-ai/README.md

@@ -2,12 +2,20 @@
 
 This directory intentionally contains only the Pi AI methods needed to serialize checkpoint and native replay history for OpenAI's Responses API. It does not contain Pi AI's complete source dependency graph.
 
-[`openai-responses-serialization.ts`](openai-responses-serialization.ts) adapts the relevant methods from `@earendil-works/pi-ai@0.84.3`. Its header lists the upstream source files. Keep the behavioral equivalence test in [`test/pi-ai-serialization.test.ts`](../../../../test/pi-ai-serialization.test.ts) passing when updating the Pi dependencies.
-
-Pi AI's `deferredToolsMode` option selects the model-compatible dynamic tool
-history representation: message-anchored `additional_tools` or the
-`tool_search_call`/`tool_search_output` pair. Without either capability,
-callers must keep every tool in the request's top-level tool list.
+[`openai-responses-serialization.ts`](openai-responses-serialization.ts) adapts the relevant methods from `@earendil-works/pi-ai@0.86.0`. Its header lists the upstream source files. Keep the wire-equivalence tests in [`test/pi-ai-serialization.test.ts`](../../../../test/pi-ai-serialization.test.ts) passing when updating the Pi dependencies.
+
+Pi AI's transcript helpers replay system sections and tool declarations.
+`supportsAdditionalTools` and `supportsToolSearch` select the dynamic tool
+history representation for additive `toolsAdded` system messages:
+message-anchored `additional_tools` or a `tool_search_call`/`tool_search_output`
+pair. Tool removal, redefinition, or a model without either capability requires
+the complete current top-level tool list.
+
+Compat uses the extension-owned `includeSystemUpdates: false` option alongside
+`includeSystemPrompt: false`. It sends the complete current prompt separately
+and preserves only supported tool additions in system-message positions.
+This keeps old prompt text from overriding current instructions after
+compaction, forced-prompt projection, reload, or resume.
 
 The optional `namespacedToolNames`, `textContentItemToolResultNames`, and `toolResultImageDetail` paths are extension-owned additions. Without those options, serialization must continue to match Pi AI. `namespacedToolNames` groups only the fixed Codex allowlist into native Responses namespaces and replays namespace/member call identities. `textContentItemToolResultNames` preserves Codex tools such as `web.run` whose successful text output is transported as an `input_text` content-item array instead of Pi's usual plain string. `toolResultImageDetail` overrides the otherwise canonical `auto` detail used for image tool-result content.
 

package/extensions/openai-codex-compat/vendor/pi-ai/openai-responses-serialization.ts

@@ -19,10 +19,17 @@ import type {
   ToolCall,
   ToolResultMessage,
 } from "@earendil-works/pi-ai";
+import {
+  getSystemMessageText,
+  normalizeContext,
+  renderSystemMessageUpdate,
+  resolveTranscript,
+  resolveTranscriptTools,
+} from "@earendil-works/pi-ai";
 
 /**
  * Focused copies of the methods used to serialize Pi messages for OpenAI's
- * Responses API. Adapted from @earendil-works/pi-ai@0.84.3:
+ * Responses API. Adapted from @earendil-works/pi-ai@0.86.0:
  *
  * - src/api/openai-responses-shared.ts
  * - src/api/transform-messages.ts
@@ -36,7 +43,6 @@ import type {
  */
 
 export type ResponsesItem = JsonRecord;
-export type DeferredToolsMode = "additional-tools" | "tool-search";
 export type ToolResultImageDetail = "auto" | "low" | "high" | "original";
 type ToolResultOutput =
   | string
@@ -47,9 +53,12 @@ type ToolResultOutput =
 
 type ConvertResponsesMessagesOptions = {
   includeSystemPrompt?: boolean;
+  /** Compat sends the complete current prompt outside replay history. */
+  includeSystemUpdates?: boolean;
   grammarToolInputProperties?: ReadonlyMap<string, string>;
-  deferredTools?: ReadonlyMap<string, Tool>;
-  deferredToolsMode?: DeferredToolsMode;
+  supportsMidConvoSystemMessages?: boolean;
+  supportsAdditionalTools?: boolean;
+  supportsToolSearch?: boolean;
   toolOptions?: ConvertResponsesToolsOptions;
   nativeAssistantItems?: ReadonlyMap<string, readonly ResponsesItem[]>;
   namespacedToolNames?: ReadonlySet<string>;
@@ -333,7 +342,7 @@ function transformMessages(
   const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
 
   const transformed = imageAwareMessages.map((message) => {
-    if (message.role === "user") return message;
+    if (message.role === "user" || message.role === "system") return message;
     if (message.role === "toolResult") {
       const normalizedId = toolCallIdMap.get(message.toolCallId);
       return normalizedId && normalizedId !== message.toolCallId
@@ -484,8 +493,11 @@ export function convertResponsesMessages(
   allowedToolCallProviders: ReadonlySet<string>,
   options?: ConvertResponsesMessagesOptions,
 ): ResponsesItem[] {
+  const transcript = resolveTranscript(
+    normalizeContext(context),
+    options?.supportsMidConvoSystemMessages,
+  );
   const messages: ResponsesItem[] = [];
-  const loadedToolNames = new Set<string>();
   const normalizeIdPart = (part: string): string => {
     const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
     const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
@@ -517,20 +529,62 @@ export function convertResponsesMessages(
     return `${normalizedCallId}|${normalizedItemId}`;
   };
 
-  const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+  const transformedMessages = transformMessages(transcript.messages, model, normalizeToolCallId);
+  const transcriptTools = resolveTranscriptTools(
+    transcript.messages,
+    (options?.supportsAdditionalTools ?? false) || (options?.supportsToolSearch ?? false),
+  );
   const includeSystemPrompt = options?.includeSystemPrompt ?? true;
-  if (includeSystemPrompt && context.systemPrompt) {
-    const supportsDeveloperRole =
-      !isObject(model.compat) || model.compat["supportsDeveloperRole"] !== false;
-    messages.push({
-      role: model.reasoning && supportsDeveloperRole ? "developer" : "system",
-      content: sanitizeSurrogates(context.systemPrompt),
-    });
-  }
+  const supportsDeveloperRole =
+    !isObject(model.compat) || model.compat["supportsDeveloperRole"] !== false;
+  const instructionRole = model.reasoning && supportsDeveloperRole ? "developer" : "system";
 
   let messageIndex = 0;
+  let sourceIndex = 0;
   for (const message of transformedMessages) {
-    if (message.role === "user") {
+    const isLeadingSystemMessage = sourceIndex++ === 0 && message.role === "system";
+    if (message.role === "system") {
+      const addedTools =
+        !isLeadingSystemMessage && transcriptTools.anchorsAdditions
+          ? (message.toolsAdded ?? [])
+          : [];
+      const toolOptions = { ...options?.toolOptions };
+      if (options?.namespacedToolNames) {
+        toolOptions.namespacedToolNames = options.namespacedToolNames;
+      }
+      if (addedTools.length > 0 && options?.supportsAdditionalTools) {
+        messages.push({
+          type: "additional_tools",
+          role: "developer",
+          tools: convertResponsesTools(addedTools, toolOptions),
+        });
+      } else if (addedTools.length > 0 && options?.supportsToolSearch) {
+        const names = addedTools.map((tool) => tool.name);
+        const callId = `pi_tool_load_${shortHash(`system:${messageIndex}:${names.join(",")}`)}`;
+        messages.push({
+          type: "tool_search_call",
+          call_id: callId,
+          execution: "client",
+          status: "completed",
+          arguments: { query: names.join(" "), limit: names.length },
+        });
+        messages.push({
+          type: "tool_search_output",
+          call_id: callId,
+          execution: "client",
+          status: "completed",
+          tools: convertResponsesTools(addedTools, { ...toolOptions, deferLoading: true }),
+        });
+      }
+      if (isLeadingSystemMessage ? includeSystemPrompt : options?.includeSystemUpdates !== false) {
+        const text = isLeadingSystemMessage
+          ? getSystemMessageText(message)
+          : renderSystemMessageUpdate(message);
+        if (text.length > 0) {
+          messages.push({ role: instructionRole, content: sanitizeSurrogates(text) });
+        }
+      }
+    } else if (message.role === "user") {
       if (isString(message.content)) {
         messages.push({
           role: "user",
@@ -650,55 +704,8 @@ export function convertResponsesMessages(
         call_id: callId,
         output,
       });
-
-      const deferredTools: Tool[] = [];
-      for (const name of message.addedToolNames ?? []) {
-        const tool = options?.deferredTools?.get(name);
-        if (!tool || loadedToolNames.has(name)) continue;
-        loadedToolNames.add(name);
-        deferredTools.push(tool);
-      }
-      if (deferredTools.length > 0 && options?.deferredToolsMode === "additional-tools") {
-        const additionalToolOptions: ConvertResponsesToolsOptions = {
-          ...options.toolOptions,
-        };
-        if (options.namespacedToolNames) {
-          additionalToolOptions.namespacedToolNames = options.namespacedToolNames;
-        }
-        messages.push({
-          type: "additional_tools",
-          role: "developer",
-          tools: convertResponsesTools(deferredTools, additionalToolOptions),
-        });
-      } else if (deferredTools.length > 0 && options?.deferredToolsMode === "tool-search") {
-        const names = deferredTools.map((tool) => tool.name);
-        const searchCallId = `pi_tool_load_${shortHash(
-          `${message.toolCallId}:${names.join(",")}`,
-        )}`;
-        messages.push({
-          type: "tool_search_call",
-          call_id: searchCallId,
-          execution: "client",
-          status: "completed",
-          arguments: { query: names.join(" "), limit: names.length },
-        });
-        const deferredToolOptions: ConvertResponsesToolsOptions = {
-          ...options?.toolOptions,
-          deferLoading: true,
-        };
-        if (options?.namespacedToolNames) {
-          deferredToolOptions.namespacedToolNames = options.namespacedToolNames;
-        }
-        messages.push({
-          type: "tool_search_output",
-          call_id: searchCallId,
-          execution: "client",
-          status: "completed",
-          tools: convertResponsesTools(deferredTools, deferredToolOptions),
-        });
-      }
     }
-    messageIndex++;
+    if (!isLeadingSystemMessage) messageIndex++;
   }
   return messages;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-codex-compat",
-  "version": "0.0.10-alpha.7",
+  "version": "0.0.10",
   "description": "OpenAI Codex compatibility for Pi with native compaction, fast mode, and Codex-optimized capabilities",
   "keywords": [
     "pi-package"
@@ -19,7 +19,11 @@
     "type": "git",
     "url": "git+https://github.com/2h2d-co/pi-openai-codex-compat.git"
   },
+  "bin": {
+    "pi-apply-patch": "./bin/pi-apply-patch.ts"
+  },
   "files": [
+    "bin",
     "extensions",
     "APPLY_PATCH_INSTRUCTION_FEEDBACK.md",
     "README.md",
@@ -47,9 +51,9 @@
   "devDependencies": {
     "@2h2d/oxlint-config": "0.1.1",
     "@2h2d/ts-config": "0.0.1",
-    "@earendil-works/pi-ai": "0.85.1",
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-tui": "0.85.1",
+    "@earendil-works/pi-ai": "0.86.0",
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@earendil-works/pi-tui": "0.86.0",
     "@types/node": "22.20.1",
     "oxfmt": "0.64.0",
     "oxlint": "1.79.0",
@@ -58,9 +62,9 @@
     "typescript": "7.0.2"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.84.0 <0.86.0",
-    "@earendil-works/pi-coding-agent": ">=0.84.0 <0.86.0",
-    "@earendil-works/pi-tui": ">=0.84.0 <0.86.0",
+    "@earendil-works/pi-ai": ">=0.86.0 <0.87.0",
+    "@earendil-works/pi-coding-agent": ">=0.86.0 <0.87.0",
+    "@earendil-works/pi-tui": ">=0.86.0 <0.87.0",
     "typebox": "*"
   },
   "engines": {