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

package/CHANGELOG.md

@@ -2,8 +2,13 @@
 
 ## 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.
 
@@ -21,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
@@ -83,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,
@@ -109,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

@@ -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:
@@ -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.                                                                                                                                                                                                                                                                                                                                                                                                                           |
@@ -478,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:
@@ -548,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/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.8",
+  "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": {