pi-codex-compaction 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -6,6 +6,22 @@ This project follows the spirit of [Keep a Changelog](https://keepachangelog.com
 
 ## [Unreleased]
 
+## [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,8 +6,11 @@ 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.
@@ -32,11 +35,11 @@ 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
 

package/SECURITY.md

@@ -19,9 +19,9 @@ 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.
 

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";
 
@@ -24,7 +26,7 @@ export default function piCodexCompaction(pi: ExtensionAPI): void {
         return pi.getAllTools()
           .filter((tool) => active.has(tool.name))
           .map(({ name, description, parameters }) => ({ name, description, parameters }));
-      });
+      }, pi.getThinkingLevel?.());
       return compaction ? { compaction } : undefined;
     } catch {
       if (!event.signal.aborted && ctx.hasUI) {
@@ -47,6 +49,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.1",
   "description": "Use OpenAI Codex RemoteCompactionV2 for supported Pi sessions.",
   "type": "module",
   "license": "MIT",
@@ -52,9 +52,9 @@
     "@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",
+    "@earendil-works/pi-ai": "^0.82.1",
+    "@earendil-works/pi-coding-agent": "^0.82.1",
+    "@types/node": "^26.1.2",
     "tsx": "^4.23.1",
     "typescript": "^7.0.2"
   },

package/src/codex-wire.ts

@@ -1,7 +1,15 @@
+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 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 {
@@ -17,28 +25,84 @@ export interface CodexCompactionRequest {
   signal?: AbortSignal;
 }
 
+export interface CodexCompactionUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  cachedInputTokens?: number;
+  reasoningTokens?: number;
+}
+
+export interface CodexCompactionResult {
+  encryptedContent: string;
+  usage?: CodexCompactionUsage;
+}
+
+/**
+ * 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> {
+  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.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,6 +110,9 @@ 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");
   }
@@ -59,48 +126,16 @@ 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");
+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");
   }
-  if (encryptedContents.size !== 1) {
-    throw new Error(`Codex compaction returned ${encryptedContents.size} checkpoint items`);
-  }
-  return [...encryptedContents][0];
+  const parser = new CompactionSseParser();
+  parser.push(sse);
+  return parser.finish();
 }
 
 function buildHeaders(request: CodexCompactionRequest, accountId: string): Headers {
@@ -124,6 +159,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 +185,290 @@ 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 }));
     }
-    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;
+
+  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 } : {}),
+    };
+  }
+
+  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);
+
+      // 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 reasoningTokens = finiteNonNegativeNumber(outputDetails?.reasoning_tokens);
+  if (
+    inputTokens === undefined &&
+    outputTokens === undefined &&
+    totalTokens === undefined &&
+    cachedInputTokens === undefined &&
+    reasoningTokens === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    ...(inputTokens !== undefined ? { inputTokens } : {}),
+    ...(outputTokens !== undefined ? { outputTokens } : {}),
+    ...(totalTokens !== undefined ? { totalTokens } : {}),
+    ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+    ...(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();
+  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);
+      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

@@ -3,7 +3,12 @@ import type { Model, Tool } 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,31 @@ export async function createRemoteCompaction(
   event: SessionBeforeCompactEvent,
   ctx: ExtensionContext,
   getTools: () => readonly ToolInfoLike[],
+  thinkingLevel?: string,
 ): Promise<{
   summary: string;
   firstKeptEntryId: string;
   tokensBefore: number;
   details: RemoteCompactionDetails;
 } | 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 +128,39 @@ 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 = {
+    ...providerPayload,
+    model: model.id,
+    store: false,
+    stream: true,
+  };
+  const boundedInput = boundCompactionInput(
+    input,
+    instructions,
+    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,
@@ -113,10 +173,14 @@ export async function createRemoteCompaction(
     tokensBefore: event.preparation.tokensBefore,
     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 +199,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 +229,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 +247,34 @@ async function captureCodexPayload(
   messages: ReturnType<typeof convertToLlm>,
   tools: readonly ToolInfoLike[],
   apiKey: string,
+  authHeaders: Record<string, string> | 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 +292,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 +433,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 {