pi-codex-compaction 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -6,6 +6,32 @@ This project follows the spirit of [Keep a Changelog](https://keepachangelog.com
 
 ## [Unreleased]
 
+## [0.1.2] - 2026-09-11
+
+### Fixed
+
+- Preserve pi-codex-tools grammar metadata and custom-tool history during remote compaction.
+- Honor pi-fast on direct compaction requests through a public event-bus contract.
+- Include cache writes and standard Pi compaction usage in session totals.
+- Restrict endpoint paths and ports; merge beta features and honor null auth headers.
+- Avoid I/O after pre-cancellation, bound total request time, and close completed SSE streams promptly.
+
+## [0.1.1] - 2026-08-06
+
+### Fixed
+
+- Let `enableInstallTelemetry: false` override an enabled `PI_TELEMETRY` environment flag.
+- Keep the normal Codex Responses request envelope while excluding Pi's retained user input from compaction history.
+- Avoid reusing opaque checkpoints across model, endpoint, account, or authentication-mode changes.
+- Avoid reusing opaque checkpoints when the authentication mode cannot be verified.
+- Reject version 1 opaque checkpoints from existing sessions and use readable fallback context until a new checkpoint is created.
+- Fall back to Pi's standard compactor when custom compaction instructions are supplied.
+
+### Added
+
+- Incremental bounded SSE parsing, transient request retries, response idle timeouts, provider usage capture, and file-operation fallback metadata.
+- Trusted-origin and redirect protections for direct Codex compaction requests.
+
 ## [0.1.0] - 2026-08-02
 
 ### Added

package/README.md

@@ -6,11 +6,14 @@ Keep long Pi sessions usable on OpenAI Codex models by replacing Pi's local summ
 
 - Uses the current `openai-codex` model for each compaction; it never silently changes the session model.
 - Sends only the history Pi is discarding, plus the previous Codex checkpoint, so the incoming/kept user message is not duplicated.
+- Retains the normal Codex Responses request envelope, including system instructions, active tool schemas, reasoning settings, prompt-cache fields, and routing fields.
 - Persists Codex's opaque encrypted checkpoint and rehydrates it only for supported Codex requests.
-- Caps compaction input and response size and falls back to standard Pi compaction on failure.
+- Reuses checkpoints only for the same model, trusted endpoint, Codex account, and authentication mode.
+- Bounds input with a UTF-8-aware token estimate, trims tool output when necessary, retries transient failures, and honors cancellation.
+- Falls back to standard Pi compaction on failure or when custom compaction instructions are requested.
 - Keeps a bounded readable transcript excerpt so switching models or providers remains usable.
 
-The current Codex catalog includes models such as `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`. Capability detection follows the provider/API contract (`openai-codex` + `openai-codex-responses`) rather than a brittle model-name list.
+The current Codex catalog includes `gpt-6-astra`, `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`. Capability detection follows the provider/API contract (`openai-codex` + `openai-codex-responses`) rather than a brittle model-name list. Use Pi 0.85.1 or later.
 
 ## Installation
 
@@ -32,14 +35,53 @@ pi -e /path/to/pi-mono/packages/pi-codex-compaction
 
 ## Behavior
 
-When Pi starts compaction on a supported Codex model, the extension sends a streamed Responses request containing a `compaction_trigger` item and the `remote_compaction_v2` beta feature. The returned opaque checkpoint is stored in the Pi compaction entry. Later supported Codex requests replace the textual compaction marker with the raw checkpoint; other providers/models receive the bounded textual fallback instead.
+When Pi starts compaction on a supported Codex model, the extension sends a streamed Responses request whose `input` contains only discardable history, any compatible prior checkpoint, and a `compaction_trigger` item. The normal request envelope is retained because Codex's compaction path is parity-tested against ordinary Responses requests; this includes the effective system prompt, active tool definitions, reasoning level, prompt-cache fields, and routing fields. The request uses the `remote_compaction_v2` beta feature, and the returned opaque checkpoint and bounded provider usage are stored in the Pi compaction entry. Later requests rehydrate the raw checkpoint only when the model, endpoint, account, and authentication mode match; other providers/models receive the bounded textual fallback instead.
 
-Compaction uses the model active when Pi triggers it. If a session switches from a larger to a smaller model, the remote request is bounded against the new model's context window and tool outputs are reduced before sending. If it still cannot fit, the extension leaves compaction to Pi's normal implementation.
+Compaction uses the model active when Pi triggers it. If a session switches from a larger to a smaller model, the remote request is bounded against the new model's context window and tool outputs are reduced before sending. A previous opaque checkpoint is treated as incompatible after a model, endpoint, account, or authentication-mode switch; Pi's readable previous summary is sent instead. If the full request still cannot fit, the extension leaves compaction to Pi's normal implementation.
 
-If the remote request fails, is cancelled, or returns an unexpected response, Pi's standard compaction path runs. No configuration is required.
+If the remote request fails, is cancelled, or returns an unexpected response, Pi's standard compaction path runs. Custom compaction instructions also use Pi's standard path because RemoteCompactionV2 has no documented custom-instructions field. The direct checkpoint request is restricted to `https://chatgpt.com`, rejects redirects, limits request/response size, and never decodes or logs `encrypted_content`. No configuration is required.
 
 ## Development
 
+### Other Codex extensions
+
+With `pi-fast` installed, direct compaction requests use the current Fast toggle.
+With `pi-codex-tools` installed, `apply_patch` keeps its raw grammar definition,
+custom-tool calls, and custom-tool results during compaction. Neither package is
+required. No package reads a private Pi tool registry.
+With `pi-openai-reasoning` installed, verified Astra requests keep the original
+request effort and receive the current effort as a configuration update.
+Failed compaction does not change saved reasoning state.
+
+Pi 0.85.1 does not expose grammar metadata in `getAllTools()`. Two synchronous,
+versioned `pi.events` contracts let cooperating extensions supply it:
+
+- `pi-codex-compaction:tools:v1`: `{ model, tools }`, before provider serialization.
+  A tool owner can attach its own `constrainedSampling` metadata.
+- `pi-codex-compaction:request:v1`: `{ ctx, messages, payload }`, after input
+  assembly and before size checks. A listener can replace `payload`. This event
+  is not the general `before_provider_request` chain and does not carry auth.
+
+Other extensions' private request changes are not applied automatically.
+Unknown third-party grammar metadata needs cooperation through the tools event.
+The checkpoint entry includes standard Pi `usage`, including cache reads and
+cache writes, as well as the original bounded token counters in `details`.
+Costs follow Pi's catalog estimates. They are not a ChatGPT subscription bill.
+
+### Reference and smoke test
+
+Behavior was checked against `openai/codex` commit
+`654b0a77d0d2f81aa21f61caf7af4be88fe550bb` (2026-09-11), notably
+`core/src/compact_remote_v2{,_attempt}.rs`. No Codex code was copied.
+RemoteCompactionV2 is a changing Codex protocol, not the public `/responses/compact`
+API. Async tools and mid-turn steering require upstream Pi support.
+
+For a small live test, load this package and select `openai-codex/gpt-6-astra`.
+Send two short messages, run `/compact`, then ask about the first message.
+Repeat with `/fast on` and `pi-codex-tools` loaded. Check that compaction succeeds,
+the continuation retains context, and session usage includes compaction tokens.
+Use only a temporary file if you test `apply_patch`. Do not generate images.
+
 ```bash
 npm install
 npm run -w packages/pi-codex-compaction check

package/SECURITY.md

@@ -19,10 +19,20 @@ Report privately through [GitHub Security Advisories](https://github.com/jvm/pi-
 
 `pi-codex-compaction` is a Pi package. Pi extensions execute with the same permissions as the local user running Pi. Users should review installed Pi packages and only install packages from sources they trust.
 
-For supported `openai-codex` models, the extension sends the portion of conversation Pi is about to discard to the OpenAI Codex Responses endpoint over HTTPS, using credentials and provider headers resolved by Pi. It stores the provider-issued opaque `encrypted_content` checkpoint in the local Pi session's compaction details so supported Codex requests can reuse it. The checkpoint is not decoded, printed, or logged.
+For supported `openai-codex` models, the extension sends the portion of conversation Pi is about to discard to the OpenAI Codex Responses endpoint over HTTPS, using credentials and provider headers resolved by Pi. The request also includes the normal Codex Responses envelope: the effective system prompt, active tool schemas, reasoning settings, and provider-generated cache/routing fields. It stores the provider-issued opaque `encrypted_content` checkpoint in the local Pi session's compaction details so compatible Codex requests can reuse it. The checkpoint is not decoded, printed, or logged.
 
-The extension bounds compaction input and response size, validates the Codex HTTPS endpoint and account claim, honors Pi cancellation, and falls back to standard Pi compaction on authentication, transport, response, or context-limit failures. A bounded textual transcript excerpt remains in the compaction summary so switching to another model or provider does not leave the session with only an unusable Codex checkpoint. The fallback may contain conversation content already present in the local session and is still subject to the user's normal Pi session-file permissions.
+The extension bounds request, compaction input, and response size, validates the HTTPS endpoint against the official `chatgpt.com` origin, rejects redirects, validates the account claim shape, binds checkpoints to a hashed account identity/model/endpoint/authentication mode, honors Pi cancellation, and retries only transient transport failures. It falls back to standard Pi compaction on authentication, transport, response, or context-limit failures. A bounded textual transcript excerpt remains in the compaction summary so switching to another model or provider does not leave the session with only an unusable Codex checkpoint. The fallback may contain conversation content already present in the local session and is still subject to the user's normal Pi session-file permissions.
 
 The extension never logs prompts, conversation contents, credentials, authorization headers, or raw provider responses. Install/update telemetry is best-effort and sends only package/version/runtime metadata; it can be disabled with `PI_OFFLINE=1`, `PI_TELEMETRY=0`, or Pi's `enableInstallTelemetry: false` setting.
 
+Direct requests allow only the official `/backend-api/codex/responses` endpoint
+on the default HTTPS port, without query strings or fragments. Total request
+time is limited to five minutes, including retries. Completed streams are closed
+without waiting for a server disconnect. A pre-aborted request does no network I/O.
+Null auth headers remove matching model headers; beta features are merged.
+
+Cooperating local extensions can inspect and transform compaction inputs through
+the documented event bus before size checks. These events contain no credentials.
+They have the same trust level as other installed Pi extensions.
+
 See [CONTRIBUTING.md](./CONTRIBUTING.md) for development and validation instructions.

package/extensions/index.ts

@@ -3,12 +3,14 @@ import type {
   ExtensionHandler,
   SessionBeforeCompactEvent,
 } from "@earendil-works/pi-coding-agent";
-import { BETA_FEATURE } from "../src/codex-wire.js";
+import { BETA_FEATURE, getCodexAccountFingerprint } from "../src/codex-wire.js";
 import { reportInstallTelemetry } from "../src/install-telemetry.js";
 import {
   applyRemoteCompactionMarker,
   createRemoteCompaction,
   findActiveRemoteCompaction,
+  getCodexAuthKind,
+  isRemoteCompactionCompatible,
   supportsRemoteCompaction,
 } from "../src/remote-compaction.js";
 
@@ -21,9 +23,20 @@ export default function piCodexCompaction(pi: ExtensionAPI): void {
     try {
       const compaction = await createRemoteCompaction(event, ctx, () => {
         const active = new Set(pi.getActiveTools());
-        return pi.getAllTools()
-          .filter((tool) => active.has(tool.name))
-          .map(({ name, description, parameters }) => ({ name, description, parameters }));
+        const data = {
+          model: ctx.model,
+          tools: pi.getAllTools().filter((tool) => active.has(tool.name)),
+        };
+        // Pi's public ToolInfo omits constrainedSampling. Tool owners can supply
+        // it here without exposing executors or inspecting private registries.
+        pi.events?.emit("pi-codex-compaction:tools:v1", data);
+        return data.tools;
+      }, pi.getThinkingLevel?.(), (payload, messages) => {
+        const data = { payload, messages, ctx };
+        // Synchronous bus contract: apply pure request transforms before bounds
+        // and before network I/O. Never include auth in this event.
+        pi.events?.emit("pi-codex-compaction:request:v1", data);
+        return data.payload;
       });
       return compaction ? { compaction } : undefined;
     } catch {
@@ -47,6 +60,23 @@ export default function piCodexCompaction(pi: ExtensionAPI): void {
     if (!supportsRemoteCompaction(ctx.model)) return;
     const details = findActiveRemoteCompaction(ctx.sessionManager.buildContextEntries());
     if (!details) return;
-    return applyRemoteCompactionMarker(event.payload, details);
+
+    return (async () => {
+      const model = ctx.model;
+      if (!model) return undefined;
+      const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+      if (!auth.ok || !auth.apiKey) return undefined;
+
+      let accountFingerprint: string;
+      try {
+        accountFingerprint = getCodexAccountFingerprint(auth.apiKey);
+      } catch {
+        return undefined;
+      }
+      if (!isRemoteCompactionCompatible(details, model, accountFingerprint, getCodexAuthKind(ctx.modelRegistry, model))) {
+        return undefined;
+      }
+      return applyRemoteCompactionMarker(event.payload, details);
+    })();
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codex-compaction",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Use OpenAI Codex RemoteCompactionV2 for supported Pi sessions.",
   "type": "module",
   "license": "MIT",
@@ -52,10 +52,10 @@
     "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.80.10",
-    "@earendil-works/pi-coding-agent": "^0.80.10",
-    "@types/node": "^26.1.1",
-    "tsx": "^4.23.1",
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@types/node": "^26.2.0",
+    "tsx": "^4.23.5",
     "typescript": "^7.0.2"
   },
   "publishConfig": {

package/src/codex-wire.ts

@@ -1,44 +1,113 @@
+import { createHash } from "node:crypto";
+
+const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 const MAX_ENCRYPTED_CONTENT_CHARS = 2_000_000;
-const REQUEST_TIMEOUT_MS = 120_000;
+const REQUEST_HEADER_TIMEOUT_MS = 30_000;
+const REQUEST_IDLE_TIMEOUT_MS = 120_000;
+const REQUEST_TOTAL_TIMEOUT_MS = 300_000;
+const MAX_RETRIES = 2;
+const RETRY_BASE_DELAY_MS = 200;
+const MAX_RETRY_DELAY_MS = 30_000;
 const ACCOUNT_ID_CLAIM = "https://api.openai.com/auth";
+const TRUSTED_CODEX_HOST = "chatgpt.com";
 export const BETA_FEATURE = "remote_compaction_v2";
 
 export interface CodexCompactionRequest {
   model: {
     id: string;
     baseUrl: string;
-    headers?: Record<string, string>;
+    headers?: Record<string, string | null>;
   };
   apiKey: string;
-  authHeaders?: Record<string, string>;
+  authHeaders?: Record<string, string | null>;
   sessionId?: string;
   body: Record<string, unknown>;
   signal?: AbortSignal;
 }
 
+export interface CodexCompactionUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  cachedInputTokens?: number;
+  cacheWriteInputTokens?: number;
+  reasoningTokens?: number;
+}
+
+export interface CodexCompactionResult {
+  encryptedContent: string;
+  usage?: CodexCompactionUsage;
+  serviceTier?: "default" | "priority" | "flex";
+}
+
+/**
+ * Keep the original string-returning API for callers that only need the
+ * checkpoint. The extension uses requestRemoteCompactionWithUsage below.
+ */
 export async function requestRemoteCompaction(request: CodexCompactionRequest): Promise<string> {
+  return (await requestRemoteCompactionWithUsage(request)).encryptedContent;
+}
+
+export async function requestRemoteCompactionWithUsage(
+  request: CodexCompactionRequest,
+): Promise<CodexCompactionResult> {
+  request.signal?.throwIfAborted();
+  const endpoint = resolveCodexResponsesUrl(request.model.baseUrl);
   const accountId = extractAccountId(request.apiKey);
   const headers = buildHeaders(request, accountId);
-  const { signal, cleanup } = requestSignal(request.signal);
+  const body = JSON.stringify(request.body);
+  if (new TextEncoder().encode(body).byteLength > MAX_REQUEST_BYTES) {
+    throw new Error("Codex compaction request exceeded the size limit");
+  }
 
+  const requestState = requestSignal(request.signal);
   try {
-    const response = await fetch(resolveCodexResponsesUrl(request.model.baseUrl), {
-      method: "POST",
-      headers,
-      body: JSON.stringify(request.body),
-      signal,
-    });
-
-    if (!response.ok) {
-      if (response.body) await response.body.cancel().catch(() => undefined);
-      throw new Error(`Codex compaction request returned HTTP ${response.status}`);
-    }
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      requestState.signal.throwIfAborted();
+      requestState.startAttempt();
+
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers,
+          body,
+          redirect: "error",
+          signal: requestState.signal,
+        });
+        requestState.headersReceived();
 
-    return parseCompactionSse(await readBoundedBody(response));
+        if (!response.ok) {
+          await response.body?.cancel().catch(() => undefined);
+          const error = new CodexCompactionError(
+            `Codex compaction request returned HTTP ${response.status}`,
+            isRetryableStatus(response.status),
+          );
+          if (!error.retryable || attempt >= MAX_RETRIES) throw error;
+          await waitForRetry(response, attempt, requestState.signal);
+          continue;
+        }
+
+        try {
+          return await readCompactionSse(response, requestState.signal, requestState.touch);
+        } catch (error) {
+          if (!isRetryableError(error) || attempt >= MAX_RETRIES || requestState.signal.aborted) {
+            throw error;
+          }
+          await waitForRetry(undefined, attempt, requestState.signal);
+        }
+      } catch (error) {
+        if (requestState.signal.aborted || !isRetryableError(error) || attempt >= MAX_RETRIES) {
+          throw error;
+        }
+        await waitForRetry(undefined, attempt, requestState.signal);
+      }
+    }
   } finally {
-    cleanup();
+    requestState.cleanup();
   }
+
+  throw new Error("Codex compaction request failed");
 }
 
 export function resolveCodexResponsesUrl(baseUrl: string): string {
@@ -46,11 +115,20 @@ export function resolveCodexResponsesUrl(baseUrl: string): string {
   if (url.protocol !== "https:") {
     throw new Error("Codex compaction requires an HTTPS endpoint");
   }
+  if (url.hostname.toLowerCase() !== TRUSTED_CODEX_HOST) {
+    throw new Error("Codex compaction endpoint is not a trusted Codex origin");
+  }
   if (url.username || url.password) {
     throw new Error("Codex compaction endpoint must not contain URL credentials");
   }
+  if (url.port || url.search || url.hash) {
+    throw new Error("Codex compaction endpoint must use the default port without query or fragment");
+  }
 
   const path = url.pathname.replace(/\/+$/, "");
+  if (!["/backend-api", "/backend-api/codex", "/backend-api/codex/responses"].includes(path)) {
+    throw new Error("Codex compaction endpoint must use the Codex Responses path");
+  }
   if (path.endsWith("/codex/responses")) {
     return url.toString();
   }
@@ -59,60 +137,34 @@ export function resolveCodexResponsesUrl(baseUrl: string): string {
 }
 
 export function parseCompactionSse(sse: string): string {
-  const encryptedContents = new Set<string>();
-  let completed = false;
-
-  for (const frame of sse.split(/\r?\n\r?\n/)) {
-    const data = frame
-      .split(/\r?\n/)
-      .filter((line) => line.startsWith("data:"))
-      .map((line) => line.slice(5).trim())
-      .join("\n")
-      .trim();
-    if (!data || data === "[DONE]") continue;
-
-    let event: unknown;
-    try {
-      event = JSON.parse(data) as unknown;
-    } catch {
-      throw new Error("Codex compaction returned invalid SSE data");
-    }
-    if (!isRecord(event)) continue;
-
-    if (event.type === "error" || event.type === "response.failed") {
-      throw new Error("Codex compaction response failed");
-    }
-
-    if (event.type === "response.output_item.done") {
-      collectCompactionItem(event.item, encryptedContents);
-    }
-
-    if (event.type === "response.completed" || event.type === "response.done") {
-      const response = isRecord(event.response) ? event.response : undefined;
-      collectOutputItems(response?.output, encryptedContents);
-      completed = response?.status === undefined || response.status === "completed";
-    }
-  }
+  return parseCompactionSseResult(sse).encryptedContent;
+}
 
-  if (!completed) {
-    throw new Error("Codex compaction stream ended before response completion");
-  }
-  if (encryptedContents.size !== 1) {
-    throw new Error(`Codex compaction returned ${encryptedContents.size} checkpoint items`);
+export function parseCompactionSseResult(sse: string): CodexCompactionResult {
+  if (new TextEncoder().encode(sse).byteLength > MAX_RESPONSE_BYTES) {
+    throw new Error("Codex compaction response exceeded the size limit");
   }
-  return [...encryptedContents][0];
+  const parser = new CompactionSseParser();
+  parser.push(sse);
+  return parser.finish();
 }
 
 function buildHeaders(request: CodexCompactionRequest, accountId: string): Headers {
   const headers = new Headers();
-  for (const [name, value] of Object.entries(request.model.headers ?? {})) headers.set(name, value);
-  for (const [name, value] of Object.entries(request.authHeaders ?? {})) headers.set(name, value);
+  for (const [name, value] of Object.entries(request.model.headers ?? {})) {
+    if (value !== null) headers.set(name, value);
+  }
+  for (const [name, value] of Object.entries(request.authHeaders ?? {})) {
+    if (value !== null) headers.set(name, value);
+    else headers.delete(name);
+  }
 
   headers.set("Authorization", `Bearer ${request.apiKey}`);
   headers.set("chatgpt-account-id", accountId);
   headers.set("originator", "pi");
   headers.set("OpenAI-Beta", "responses=experimental");
-  headers.set("x-codex-beta-features", BETA_FEATURE);
+  const features = headers.get("x-codex-beta-features")?.split(",").map((part) => part.trim()).filter(Boolean) ?? [];
+  headers.set("x-codex-beta-features", [...new Set([...features, BETA_FEATURE])].join(","));
   headers.set("accept", "text/event-stream");
   headers.set("content-type", "application/json");
 
@@ -124,6 +176,10 @@ function buildHeaders(request: CodexCompactionRequest, accountId: string): Heade
   return headers;
 }
 
+export function getCodexAccountFingerprint(token: string): string {
+  return `sha256:${createHash("sha256").update(extractAccountId(token)).digest("hex")}`;
+}
+
 function extractAccountId(token: string): string {
   const segment = token.split(".")[1];
   if (!segment) throw new Error("Codex authentication token has no account claim");
@@ -146,61 +202,307 @@ function safeSessionId(value: string | undefined): string | undefined {
   return value;
 }
 
-function collectOutputItems(value: unknown, encryptedContents: Set<string>): void {
-  if (!Array.isArray(value)) return;
-  for (const item of value) collectCompactionItem(item, encryptedContents);
-}
-
-function collectCompactionItem(value: unknown, encryptedContents: Set<string>): void {
-  if (!isRecord(value) || value.type !== "compaction") return;
-  const encryptedContent = value.encrypted_content;
-  if (
-    typeof encryptedContent === "string" &&
-    encryptedContent.length > 0 &&
-    encryptedContent.length <= MAX_ENCRYPTED_CONTENT_CHARS
-  ) {
-    encryptedContents.add(encryptedContent);
+async function readCompactionSse(
+  response: Response,
+  signal: AbortSignal,
+  touch: () => void,
+): Promise<CodexCompactionResult> {
+  if (!response.body) {
+    throw new CodexCompactionError("Codex compaction response has no body", true);
   }
-}
-
-async function readBoundedBody(response: Response): Promise<string> {
-  if (!response.body) throw new Error("Codex compaction response has no body");
 
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
+  const parser = new CompactionSseParser();
   let bytes = 0;
-  let text = "";
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
+      touch();
       bytes += value.byteLength;
       if (bytes > MAX_RESPONSE_BYTES) {
-        throw new Error("Codex compaction response exceeded the size limit");
+        throw new CodexCompactionError("Codex compaction response exceeded the size limit", false);
       }
-      text += decoder.decode(value, { stream: true });
+      parser.push(decoder.decode(value, { stream: true }));
+      if (parser.isComplete) return parser.finish();
     }
-    return text + decoder.decode();
+    parser.push(decoder.decode());
+    return parser.finish();
+  } catch (error) {
+    if (error instanceof CodexCompactionError) throw error;
+    if (signal.aborted) throw error;
+    throw new CodexCompactionError("Codex compaction response stream failed", true);
   } finally {
     await reader.cancel().catch(() => undefined);
     reader.releaseLock();
   }
 }
 
-function requestSignal(signal: AbortSignal | undefined): { signal: AbortSignal; cleanup: () => void } {
+class CompactionSseParser {
+  private buffer = "";
+  private completed = false;
+  private status: string | undefined;
+  private compactionItems: Array<string | undefined> = [];
+  private usage: CodexCompactionUsage | undefined;
+  private serviceTier: CodexCompactionResult["serviceTier"];
+
+  get isComplete(): boolean {
+    return this.completed;
+  }
+
+  push(chunk: string): void {
+    this.buffer += chunk;
+    this.buffer = this.buffer.replace(/\r\n/g, "\n");
+    while (true) {
+      const separator = this.buffer.indexOf("\n\n");
+      if (separator < 0) break;
+      const frame = this.buffer.slice(0, separator);
+      this.buffer = this.buffer.slice(separator + 2);
+      this.processFrame(frame);
+    }
+  }
+
+  finish(): CodexCompactionResult {
+    if (this.buffer.trim()) this.processFrame(this.buffer);
+    if (!this.completed) {
+      throw new CodexCompactionError("Codex compaction stream ended before response completion", true);
+    }
+    if (this.status && this.status !== "completed") {
+      throw new CodexCompactionError("Codex compaction response failed", false);
+    }
+    if (this.compactionItems.length !== 1) {
+      throw new CodexCompactionError(
+        `Codex compaction returned ${this.compactionItems.length} checkpoint items`,
+        false,
+      );
+    }
+
+    const encryptedContent = this.compactionItems[0];
+    if (!encryptedContent) {
+      throw new CodexCompactionError("Codex compaction returned an invalid checkpoint", false);
+    }
+    return {
+      encryptedContent,
+      ...(this.usage ? { usage: this.usage } : {}),
+      ...(this.serviceTier ? { serviceTier: this.serviceTier } : {}),
+    };
+  }
+
+  private processFrame(frame: string): void {
+    const data = frame
+      .split("\n")
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trim())
+      .join("\n")
+      .trim();
+    if (!data || data === "[DONE]") return;
+
+    let event: unknown;
+    try {
+      event = JSON.parse(data) as unknown;
+    } catch {
+      throw new CodexCompactionError("Codex compaction returned invalid SSE data", false);
+    }
+    if (!isRecord(event)) return;
+
+    if (event.type === "error" || event.type === "response.failed") {
+      throw new CodexCompactionError("Codex compaction response failed", false);
+    }
+
+    if (event.type === "response.output_item.done") {
+      this.collectCompactionItem(event.item);
+    }
+
+    if (event.type === "response.completed" || event.type === "response.done") {
+      const response = isRecord(event.response) ? event.response : undefined;
+      this.status = typeof response?.status === "string" ? response.status : undefined;
+      this.usage = parseUsage(response?.usage ?? event.usage);
+      const tier = response?.service_tier;
+      this.serviceTier = tier === "default" || tier === "priority" || tier === "flex" ? tier : undefined;
+
+      // Codex emits output_item.done before response.completed. Retain this
+      // fallback for compact Responses implementations that only return the
+      // completed response's output array.
+      if (this.compactionItems.length === 0) {
+        collectOutputItems(response?.output, (item) => this.collectCompactionItem(item));
+      }
+      this.completed = true;
+    }
+  }
+
+  private collectCompactionItem(value: unknown): void {
+    if (!isRecord(value) || value.type !== "compaction") return;
+    const encryptedContent = value.encrypted_content;
+    this.compactionItems.push(
+      typeof encryptedContent === "string" &&
+        encryptedContent.length > 0 &&
+        encryptedContent.length <= MAX_ENCRYPTED_CONTENT_CHARS
+        ? encryptedContent
+        : undefined,
+    );
+  }
+}
+
+function collectOutputItems(value: unknown, collect: (item: unknown) => void): void {
+  if (!Array.isArray(value)) return;
+  for (const item of value) collect(item);
+}
+
+function parseUsage(value: unknown): CodexCompactionUsage | undefined {
+  if (!isRecord(value)) return undefined;
+  const inputTokens = finiteNonNegativeNumber(value.input_tokens);
+  const outputTokens = finiteNonNegativeNumber(value.output_tokens);
+  const totalTokens = finiteNonNegativeNumber(value.total_tokens);
+  const inputDetails = isRecord(value.input_tokens_details) ? value.input_tokens_details : undefined;
+  const outputDetails = isRecord(value.output_tokens_details) ? value.output_tokens_details : undefined;
+  const cachedInputTokens = finiteNonNegativeNumber(inputDetails?.cached_tokens);
+  const cacheWriteInputTokens = finiteNonNegativeNumber(inputDetails?.cache_write_tokens);
+  const reasoningTokens = finiteNonNegativeNumber(outputDetails?.reasoning_tokens);
+  if (
+    inputTokens === undefined &&
+    outputTokens === undefined &&
+    totalTokens === undefined &&
+    cachedInputTokens === undefined &&
+    cacheWriteInputTokens === undefined &&
+    reasoningTokens === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    ...(inputTokens !== undefined ? { inputTokens } : {}),
+    ...(outputTokens !== undefined ? { outputTokens } : {}),
+    ...(totalTokens !== undefined ? { totalTokens } : {}),
+    ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+    ...(cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens } : {}),
+    ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+  };
+}
+
+function finiteNonNegativeNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status === 408 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+
+async function waitForRetry(
+  response: Response | undefined,
+  attempt: number,
+  signal: AbortSignal,
+): Promise<void> {
+  const retryAfter = response ? parseRetryAfter(response.headers) : undefined;
+  const delay = Math.min(
+    MAX_RETRY_DELAY_MS,
+    retryAfter ?? RETRY_BASE_DELAY_MS * 2 ** attempt,
+  );
+  await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(signal.reason ?? new Error("Codex compaction request aborted"));
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delay);
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+  });
+}
+
+function parseRetryAfter(headers: Headers): number | undefined {
+  const milliseconds = headers.get("retry-after-ms");
+  if (milliseconds) {
+    const value = Number(milliseconds);
+    if (Number.isFinite(value) && value >= 0) return value;
+  }
+  const seconds = headers.get("retry-after");
+  if (!seconds) return undefined;
+  const numeric = Number(seconds);
+  if (Number.isFinite(numeric) && numeric >= 0) return numeric * 1_000;
+  const date = Date.parse(seconds);
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+}
+
+class CodexCompactionError extends Error {
+  constructor(
+    message: string,
+    readonly retryable: boolean,
+  ) {
+    super(message);
+    this.name = "CodexCompactionError";
+  }
+}
+
+function isRetryableError(error: unknown): boolean {
+  return error instanceof CodexCompactionError
+    ? error.retryable
+    : error instanceof Error;
+}
+
+interface RequestSignal {
+  signal: AbortSignal;
+  startAttempt: () => void;
+  headersReceived: () => void;
+  touch: () => void;
+  cleanup: () => void;
+}
+
+function requestSignal(signal: AbortSignal | undefined): RequestSignal {
   const controller = new AbortController();
+  const totalTimeout = setTimeout(
+    () => controller.abort(new Error("Codex compaction request exceeded the total time limit")),
+    REQUEST_TOTAL_TIMEOUT_MS,
+  );
+  let headerTimeout: ReturnType<typeof setTimeout> | undefined;
+  let idleTimeout: ReturnType<typeof setTimeout> | undefined;
+
   const onAbort = () => controller.abort(signal?.reason);
   if (signal?.aborted) {
     controller.abort(signal.reason);
   } else {
     signal?.addEventListener("abort", onAbort, { once: true });
   }
-  const timeout = setTimeout(() => controller.abort(new Error("Codex compaction request timed out")), REQUEST_TIMEOUT_MS);
+
+  const clearTimers = () => {
+    if (headerTimeout) clearTimeout(headerTimeout);
+    if (idleTimeout) clearTimeout(idleTimeout);
+    headerTimeout = undefined;
+    idleTimeout = undefined;
+  };
+  const touch = () => {
+    if (idleTimeout) clearTimeout(idleTimeout);
+    idleTimeout = setTimeout(
+      () => controller.abort(new Error("Codex compaction response idle timeout")),
+      REQUEST_IDLE_TIMEOUT_MS,
+    );
+  };
 
   return {
     signal: controller.signal,
+    startAttempt: () => {
+      clearTimers();
+      headerTimeout = setTimeout(
+        () => controller.abort(new Error("Codex compaction request timed out waiting for response headers")),
+        REQUEST_HEADER_TIMEOUT_MS,
+      );
+    },
+    headersReceived: () => {
+      if (headerTimeout) clearTimeout(headerTimeout);
+      headerTimeout = undefined;
+      touch();
+    },
+    touch,
     cleanup: () => {
-      clearTimeout(timeout);
+      clearTimeout(totalTimeout);
+      clearTimers();
       signal?.removeEventListener("abort", onAbort);
     },
   };

package/src/install-telemetry.ts

@@ -46,14 +46,15 @@ function isPresentEnvFlag(value: string | undefined): boolean {
   return normalized !== "0" && normalized !== "false" && normalized !== "no";
 }
 
-function isInstallTelemetryEnabled(): boolean {
-  if (isTruthyEnvFlag(process.env.CI)) return false;
-  if (CI_ENVIRONMENT_VARIABLES.some((name) => isPresentEnvFlag(process.env[name]))) return false;
-  if (isTruthyEnvFlag(process.env.PI_OFFLINE)) return false;
-  if (process.env.PI_TELEMETRY !== undefined) return isTruthyEnvFlag(process.env.PI_TELEMETRY);
+export function isInstallTelemetryEnabled(env: NodeJS.ProcessEnv = process.env, settingsPath = join(getAgentDir(), "settings.json")): boolean {
+  if (isTruthyEnvFlag(env.CI)) return false;
+  if (CI_ENVIRONMENT_VARIABLES.some((name) => isPresentEnvFlag(env[name]))) return false;
+  if (isTruthyEnvFlag(env.PI_OFFLINE)) return false;
 
-  const settings = readJsonFile(join(getAgentDir(), "settings.json")) as PiSettingsDocument;
-  return settings.enableInstallTelemetry !== false;
+  const settings = readJsonFile(settingsPath) as PiSettingsDocument;
+  if (settings.enableInstallTelemetry === false) return false;
+  if (env.PI_TELEMETRY !== undefined) return isTruthyEnvFlag(env.PI_TELEMETRY);
+  return true;
 }
 
 function getPackageVersion(): string {

package/src/remote-compaction.ts

@@ -1,9 +1,14 @@
 import { stream as captureProviderPayload } from "@earendil-works/pi-ai/compat";
-import type { Model, Tool } from "@earendil-works/pi-ai";
+import { calculateCost, type Model, type Tool, type Usage } from "@earendil-works/pi-ai";
 import type { ExtensionContext, SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
 import { convertToLlm, serializeConversation, sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import { requestRemoteCompaction } from "./codex-wire.js";
+import {
+  getCodexAccountFingerprint,
+  requestRemoteCompactionWithUsage,
+  resolveCodexResponsesUrl,
+  type CodexCompactionUsage,
+} from "./codex-wire.js";
 
 export const REMOTE_SUMMARY_MARKER = "[pi-codex-compaction:v1]";
 export const REMOTE_COMPACTION_KIND = "pi-codex-compaction";
@@ -16,14 +21,24 @@ const PI_COMPACTION_SUMMARY_PREFIX = "The conversation history before this point
 
 export interface RemoteCompactionDetails {
   kind: typeof REMOTE_COMPACTION_KIND;
-  version: 1;
+  version: 2;
   provider: "openai-codex";
   model: string;
+  endpoint: string;
+  accountFingerprint: string;
+  authKind: CodexAuthKind;
   encryptedContent: string;
+  usage?: CodexCompactionUsage;
 }
 
-type CodexModel = Pick<Model<any>, "id" | "api" | "provider" | "baseUrl" | "contextWindow" | "headers">;
+export type CodexAuthKind = "oauth" | "api-key" | "unknown";
+
+type CodexModel = Pick<
+  Model<any>,
+  "id" | "api" | "provider" | "baseUrl" | "contextWindow" | "headers" | "reasoning"
+>;
 type AgentMessage = ReturnType<typeof sessionEntryToContextMessages>[number];
+type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 
 export function supportsRemoteCompaction(model: Pick<CodexModel, "api" | "provider"> | undefined): boolean {
   return model?.provider === "openai-codex" && model.api === "openai-codex-responses";
@@ -38,6 +53,28 @@ export function findActiveRemoteCompaction(entries: readonly SessionEntry[]): Re
   return undefined;
 }
 
+/**
+ * Check the model, endpoint, and account before reusing an opaque checkpoint.
+ * The checkpoint is intentionally not treated as portable across those
+ * boundaries because the service can bind its encryption to them.
+ */
+export function isRemoteCompactionCompatible(
+  details: RemoteCompactionDetails,
+  model: Pick<CodexModel, "id" | "api" | "provider" | "baseUrl">,
+  accountFingerprint: string,
+  authKind: CodexAuthKind = "unknown",
+): boolean {
+  if (!supportsRemoteCompaction(model) || details.model !== model.id) return false;
+  if (details.accountFingerprint !== accountFingerprint) return false;
+  if (details.authKind === "unknown" || authKind === "unknown") return false;
+  if (details.authKind !== authKind) return false;
+  try {
+    return details.endpoint === resolveCodexResponsesUrl(model.baseUrl);
+  } catch {
+    return false;
+  }
+}
+
 export function applyRemoteCompactionMarker(payload: unknown, details: RemoteCompactionDetails): unknown | undefined {
   if (!isRecord(payload) || !Array.isArray(payload.input)) return undefined;
 
@@ -57,19 +94,33 @@ export async function createRemoteCompaction(
   event: SessionBeforeCompactEvent,
   ctx: ExtensionContext,
   getTools: () => readonly ToolInfoLike[],
+  thinkingLevel?: string,
+  prepareRequest?: (payload: Record<string, unknown>, messages: readonly AgentMessage[]) => Record<string, unknown>,
 ): Promise<{
   summary: string;
   firstKeptEntryId: string;
   tokensBefore: number;
   details: RemoteCompactionDetails;
+  usage?: Usage;
 } | undefined> {
+  // Pi's custom focus is part of the standard summarizer contract. The
+  // Responses compaction envelope has no documented equivalent, so do not
+  // silently discard it.
+  if (event.customInstructions?.trim()) return undefined;
+
   const model = ctx.model as CodexModel | undefined;
   if (!model || !supportsRemoteCompaction(model)) return undefined;
 
+  const endpoint = resolveCodexResponsesUrl(model.baseUrl);
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model as Model<any>);
   if (!auth.ok || !auth.apiKey) return undefined;
+  const accountFingerprint = getCodexAccountFingerprint(auth.apiKey);
+  const authKind = getCodexAuthKind(ctx.modelRegistry, model as Model<any>);
 
   const previous = findActiveRemoteCompaction(ctx.sessionManager.buildContextEntries());
+  const compatiblePrevious = previous && isRemoteCompactionCompatible(previous, model, accountFingerprint, authKind)
+    ? previous
+    : undefined;
   const messages = [...event.preparation.messagesToSummarize, ...event.preparation.turnPrefixMessages];
   const instructions = ctx.getSystemPrompt() || "You are a helpful assistant.";
   const sessionId = ctx.sessionManager.getSessionId();
@@ -79,28 +130,43 @@ export async function createRemoteCompaction(
     convertToLlm(messages),
     getTools(),
     auth.apiKey,
+    auth.headers,
     sessionId,
     event.signal,
+    thinkingLevel,
   );
   if (!providerPayload) return undefined;
   const providerInput = providerPayload.input;
   if (!Array.isArray(providerInput)) return undefined;
   const providerTools = Array.isArray(providerPayload.tools) ? providerPayload.tools : [];
 
-  const input = appendCompactionItems(providerInput, event.preparation, previous);
-  const boundedInput = boundCompactionInput(input, instructions, providerTools, model.contextWindow);
+  const input = appendCompactionItems(providerInput, event.preparation, compatiblePrevious);
+  const requestBody = prepareRequest?.({
+    ...providerPayload,
+    input,
+  }, messages) ?? { ...providerPayload, input };
+  Object.assign(requestBody, {
+    model: model.id,
+    store: false,
+    stream: true,
+  });
+  if (!Array.isArray(requestBody.input)) return undefined;
+  const boundedInput = boundCompactionInput(
+    requestBody.input,
+    instructions,
+    Array.isArray(requestBody.tools) ? requestBody.tools : providerTools,
+    model.contextWindow,
+    requestBody,
+  );
   if (!boundedInput) return undefined;
 
-  const encryptedContent = await requestRemoteCompaction({
+  const result = await requestRemoteCompactionWithUsage({
     model,
     apiKey: auth.apiKey,
     authHeaders: auth.headers,
     sessionId,
     body: {
-      ...providerPayload,
-      model: model.id,
-      store: false,
-      stream: true,
+      ...requestBody,
       input: boundedInput,
     },
     signal: event.signal,
@@ -111,12 +177,21 @@ export async function createRemoteCompaction(
     summary: `${REMOTE_SUMMARY_MARKER}\n\n${fallback}`,
     firstKeptEntryId: event.preparation.firstKeptEntryId,
     tokensBefore: event.preparation.tokensBefore,
+    ...(result.usage ? { usage: toPiUsage(
+      result.usage,
+      ctx.model!,
+      result.serviceTier && result.serviceTier !== "default" ? result.serviceTier : requestBody.service_tier,
+    ) } : {}),
     details: {
       kind: REMOTE_COMPACTION_KIND,
-      version: 1,
+      version: 2,
       provider: "openai-codex",
       model: model.id,
-      encryptedContent,
+      endpoint,
+      accountFingerprint,
+      authKind,
+      encryptedContent: result.encryptedContent,
+      ...(result.usage ? { usage: result.usage } : {}),
     },
   };
 }
@@ -135,29 +210,28 @@ export function boundCompactionInput(
   instructions: string,
   tools: readonly unknown[],
   contextWindow: number,
+  requestPayload?: Record<string, unknown>,
 ): unknown[] | undefined {
-  const budget = Math.max(1, contextWindow - COMPACTION_RESPONSE_RESERVE_TOKENS);
+  const budget = Math.max(1, Math.floor(contextWindow - COMPACTION_RESPONSE_RESERVE_TOKENS));
+  // A byte-level bound is conservative when the active model's tokenizer is unavailable:
+  // a token can be represented by a single UTF-8 byte, but not fewer.
+  const budgetBytes = budget;
   const bounded = input.map((item) => item);
-  let estimatedTokens = estimateConservativeTokens({ instructions, input: bounded, tools });
-  const fits = () => estimatedTokens <= budget;
-  if (fits()) return bounded;
+  let requestBytes = estimateConservativeBytes(
+    buildCompactionRequest(requestPayload, bounded, instructions, tools),
+  );
+  if (requestBytes <= budgetBytes) return bounded;
 
   // ponytail: trim tool outputs first; if structural content still exceeds the active model window,
   // let Pi's standard compaction path handle the request instead of inventing a lossy transcript rewrite.
   for (let index = bounded.length - 1; index >= 0; index--) {
     const item = bounded[index];
-    if (!isRecord(item)) continue;
-
-    const replacement = item.type === "function_call_output"
-      ? { ...item, output: TRUNCATED_TOOL_OUTPUT }
-      : item.type === "tool_search_output"
-        ? { ...item, tools: [] }
-        : undefined;
+    const replacement = trimToolOutput(item);
     if (!replacement) continue;
 
-    estimatedTokens += estimateConservativeTokens(replacement) - estimateConservativeTokens(item);
+    requestBytes += estimateConservativeBytes(replacement) - estimateConservativeBytes(item);
     bounded[index] = replacement;
-    if (fits()) return bounded;
+    if (requestBytes <= budgetBytes) return bounded;
   }
 
   return undefined;
@@ -166,10 +240,12 @@ export function boundCompactionInput(
 export function buildFallbackSummary(preparation: SessionBeforeCompactEvent["preparation"], messages: AgentMessage[]): string {
   const transcript = serializeConversation(convertToLlm(messages));
   const previous = preparation.previousSummary ? `Previous checkpoint fallback:\n${preparation.previousSummary}` : "";
+  const fileOperations = formatFileOperations(preparation.fileOps);
   const content = [
     "This checkpoint is opaque to non-Codex providers. Use the transcript excerpt below when continuing this session.",
     previous,
     transcript ? `Discarded conversation excerpt:\n${transcript}` : "",
+    fileOperations,
   ]
     .filter(Boolean)
     .join("\n\n");
@@ -182,26 +258,34 @@ async function captureCodexPayload(
   messages: ReturnType<typeof convertToLlm>,
   tools: readonly ToolInfoLike[],
   apiKey: string,
+  authHeaders: Record<string, string | null> | undefined,
   sessionId: string,
   signal: AbortSignal,
+  thinkingLevel: string | undefined,
 ): Promise<Record<string, unknown> | undefined> {
   if (signal.aborted) return undefined;
 
   let payload: unknown;
   const captureError = new Error("capture Codex request payload");
-  const stream = captureProviderPayload(model as Model<any>, {
-    systemPrompt: instructions,
-    messages,
-    tools: [...tools],
-  }, {
+  const options: Record<string, unknown> = {
     apiKey,
+    headers: authHeaders,
     sessionId,
     signal,
-    onPayload(next) {
+    onPayload(next: unknown) {
       payload = next;
       throw captureError;
     },
-  });
+  };
+  if (model.reasoning && isThinkingLevel(thinkingLevel) && thinkingLevel !== "off") {
+    options.reasoningEffort = thinkingLevel;
+  }
+
+  const stream = captureProviderPayload(model as Model<any>, {
+    systemPrompt: instructions,
+    messages,
+    tools: [...tools],
+  }, options);
 
   await stream.result();
   return isRecord(payload) ? payload : undefined;
@@ -219,7 +303,9 @@ function appendCompactionItems(
     output.unshift({
       type: "message",
       role: "user",
-      content: [{ type: "input_text", text: limitText(preparation.previousSummary, FALLBACK_SUMMARY_MAX_CHARS) }],
+      // This is bounded together with the complete request envelope below;
+      // the readable fallback limit is only for non-Codex continuation.
+      content: [{ type: "input_text", text: preparation.previousSummary }],
       status: "completed",
     });
   }
@@ -358,19 +444,97 @@ function isRemoteCompactionDetails(value: unknown): value is RemoteCompactionDet
   return (
     isRecord(value) &&
     value.kind === REMOTE_COMPACTION_KIND &&
-    value.version === 1 &&
+    value.version === 2 &&
     value.provider === "openai-codex" &&
     typeof value.model === "string" &&
     value.model.length > 0 &&
+    value.model.length <= 256 &&
+    typeof value.endpoint === "string" &&
+    value.endpoint.length <= 2_048 &&
+    typeof value.accountFingerprint === "string" &&
+    /^sha256:[a-f0-9]{64}$/.test(value.accountFingerprint) &&
+    (value.authKind === "oauth" || value.authKind === "api-key" || value.authKind === "unknown") &&
     typeof value.encryptedContent === "string" &&
     value.encryptedContent.length > 0 &&
-    value.encryptedContent.length <= MAX_ENCRYPTED_CONTENT_CHARS
+    value.encryptedContent.length <= MAX_ENCRYPTED_CONTENT_CHARS &&
+    (value.usage === undefined || isCodexCompactionUsage(value.usage))
   );
 }
 
-function estimateConservativeTokens(value: unknown): number {
-  // One UTF-8 byte per token is deliberately conservative without a provider tokenizer.
-  return new TextEncoder().encode(JSON.stringify(value) ?? "").byteLength;
+export function getCodexAuthKind(
+  modelRegistry: unknown,
+  model: Model<any>,
+): CodexAuthKind {
+  const isUsingOAuth = isRecord(modelRegistry) ? modelRegistry.isUsingOAuth : undefined;
+  if (typeof isUsingOAuth !== "function") return "unknown";
+  try {
+    return isUsingOAuth.call(modelRegistry, model) ? "oauth" : "api-key";
+  } catch {
+    return "unknown";
+  }
+}
+
+function isCodexCompactionUsage(value: unknown): value is CodexCompactionUsage {
+  return isRecord(value) && Object.values(value).every(
+    (entry) => typeof entry === "number" && Number.isFinite(entry) && entry >= 0,
+  );
+}
+
+function buildCompactionRequest(
+  requestPayload: Record<string, unknown> | undefined,
+  input: readonly unknown[],
+  instructions: string,
+  tools: readonly unknown[],
+): Record<string, unknown> {
+  const payload: Record<string, unknown> = requestPayload ? { ...requestPayload } : {};
+  payload.instructions = instructions;
+  payload.input = input;
+  if (tools.length > 0 || requestPayload && "tools" in requestPayload) payload.tools = tools;
+  return payload;
+}
+
+function trimToolOutput(value: unknown): unknown | undefined {
+  if (!isRecord(value)) return undefined;
+  if (
+    (value.type === "function_call_output" ||
+      value.type === "custom_tool_call_output" ||
+      value.type === "local_shell_call_output" ||
+      value.type === "computer_call_output") &&
+    value.output !== undefined
+  ) {
+    return { ...value, output: TRUNCATED_TOOL_OUTPUT };
+  }
+  if (value.type === "tool_search_output" && Array.isArray(value.tools)) {
+    return { ...value, tools: [] };
+  }
+  return undefined;
+}
+
+function estimateConservativeBytes(value: unknown): number {
+  try {
+    const json = JSON.stringify(value) ?? "";
+    return new TextEncoder().encode(json).byteLength;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+
+function formatFileOperations(fileOps: { read: Set<string>; edited: Set<string> }): string {
+  const read = [...fileOps.read].filter((path): path is string => typeof path === "string").sort();
+  const edited = [...fileOps.edited].filter((path): path is string => typeof path === "string").sort();
+  if (read.length === 0 && edited.length === 0) return "";
+  return [
+    "File operations in discarded history:",
+    read.length > 0 ? `- Read: ${read.join(", ")}` : "",
+    edited.length > 0 ? `- Modified: ${edited.join(", ")}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function isThinkingLevel(value: string | undefined): value is ThinkingLevel {
+  return value === "off" || value === "minimal" || value === "low" || value === "medium" ||
+    value === "high" || value === "xhigh" || value === "max";
 }
 
 function limitText(text: string, maxChars: number): string {
@@ -381,7 +545,27 @@ function limitText(text: string, maxChars: number): string {
   return `${text.slice(0, head)}${omission}${text.slice(text.length - (available - head))}`;
 }
 
-type ToolInfoLike = Pick<Tool, "name" | "description" | "parameters">;
+type ToolInfoLike = Tool;
+
+function toPiUsage(raw: CodexCompactionUsage, model: Model<any>, tier: unknown): Usage {
+  const cacheRead = raw.cachedInputTokens ?? 0;
+  const cacheWrite = raw.cacheWriteInputTokens ?? 0;
+  const output = raw.outputTokens ?? 0;
+  const usage: Usage = {
+    input: Math.max(0, (raw.inputTokens ?? 0) - cacheRead - cacheWrite),
+    output,
+    cacheRead,
+    cacheWrite,
+    ...(raw.reasoningTokens !== undefined ? { reasoning: raw.reasoningTokens } : {}),
+    totalTokens: raw.totalTokens ?? (raw.inputTokens ?? 0) + output,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+  calculateCost(model, usage);
+  // Match Pi 0.85.1's catalog estimates, not subscription credit accounting.
+  const multiplier = tier === "priority" ? (model.id === "gpt-5.5" ? 2.5 : 2) : tier === "flex" ? 0.5 : 1;
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"] as const) usage.cost[key] *= multiplier;
+  return usage;
+}
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);