@howaboua/pi-codex-conversion 1.5.10-dev.39.e39a154 → 1.5.10-dev.44.ec03884

package/README.md

@@ -9,7 +9,7 @@ GPT/Codex models are strongest when the tool surface looks like the Codex CLI th
 
 The point is to give the model tools it already knows how to use well: shell-first inspection, resumable command sessions, and large one-shot patch edits instead of piecemeal read/edit/write steps.
 
-You can also opt into using the adapter on every provider/model. YMMV: Codex-tuned models are still the best fit, but the shell/patch workflow can help elsewhere too. The extension also has a small `/codex` settings UI for toggling adapter behavior, web search, image generation, fast mode, and verbosity. See [Settings](#settings).
+You can also opt into using the adapter on every provider/model. YMMV: Codex-tuned models are still the best fit, but the shell/patch workflow can help elsewhere too. The extension also has a small `/codex` settings UI for toggling adapter behavior, web search, image generation, fast mode, native Responses compaction, and verbosity. See [Settings](#settings).
 
 ## Install
 
@@ -55,6 +55,10 @@ The settings UI also has **Usage**, **Overrides**, and **About** tabs. **Usage**
 
 - add only the Pi `apply_patch` tool for GPT/Codex models while keeping Pi's default toolkit, prompt, provider behavior, and compaction flow
 
+The **Compaction** tab can enable native OpenAI Responses compaction and choose the compaction model/reasoning. If native compaction fails, the extension falls back to Pi's normal compaction flow; when an older native compacted window exists, it is included in that Pi fallback summarization request so OpenAI can still use the prior opaque context server-side.
+
+For OpenAI Codex subscription models, the extension also adjusts Pi's registered model context windows so Pi's fixed reserve-token compaction heuristic trips at roughly Codex's native auto-compact budget: 90% of Pi's resolved model window. This is calculated from Pi's current model metadata instead of hardcoded per-model limits.
+
 When `all` is on, non-Codex providers get the shell, patch, skill, and prompt-adapter behavior, but keep their normal Pi provider path. Native web search, native image generation, and priority service tier stay limited to the OpenAI Codex provider. Verbosity is applied to Responses API providers.
 
 The footer shows the active state, for example:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.5.10-dev.39.e39a154",
+  "version": "1.5.10-dev.44.ec03884",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -60,9 +60,10 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.75.3",
-    "@earendil-works/pi-coding-agent": "^0.75.3",
-    "@earendil-works/pi-tui": "^0.75.3",
+    "@earendil-works/pi-agent-core": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.75.4",
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@earendil-works/pi-tui": "^0.75.4",
     "tsx": "^4.20.5",
     "typebox": "^1.1.24",
     "typescript": "^5.9.3"

package/src/adapter/codex-context-budget.ts

@@ -0,0 +1,93 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { AdapterState } from "./state.ts";
+
+const OPENAI_CODEX_PROVIDER = "openai-codex";
+const OPENAI_CODEX_API = "openai-codex-responses";
+const CODEX_AUTO_COMPACT_NUMERATOR = 9;
+const CODEX_AUTO_COMPACT_DENOMINATOR = 10;
+const PI_DEFAULT_COMPACTION_RESERVE_TOKENS = 16_384;
+
+export function getCodexAutoCompactBudget(contextWindow: number): number {
+	return Math.floor((contextWindow * CODEX_AUTO_COMPACT_NUMERATOR) / CODEX_AUTO_COMPACT_DENOMINATOR);
+}
+
+export function getPiContextWindowForCodexAutoCompact(contextWindow: number, reserveTokens = PI_DEFAULT_COMPACTION_RESERVE_TOKENS): number {
+	return Math.min(contextWindow, getCodexAutoCompactBudget(contextWindow) + reserveTokens);
+}
+
+function readSettings(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) return undefined;
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function getReserveTokens(settings: Record<string, unknown> | undefined): number | undefined {
+	const compaction = settings?.compaction;
+	if (!compaction || typeof compaction !== "object" || Array.isArray(compaction)) return undefined;
+	const reserveTokens = (compaction as { reserveTokens?: unknown }).reserveTokens;
+	return typeof reserveTokens === "number" && Number.isFinite(reserveTokens) && reserveTokens >= 0 ? reserveTokens : undefined;
+}
+
+export function readPiCompactionReserveTokens(cwd: string): number {
+	return (
+		getReserveTokens(readSettings(join(cwd, ".pi", "settings.json"))) ??
+		getReserveTokens(readSettings(join(getAgentDir(), "settings.json"))) ??
+		PI_DEFAULT_COMPACTION_RESERVE_TOKENS
+	);
+}
+
+export function shouldUseCodexContextBudgetModel(model: Model<Api> | undefined): model is Model<Api> {
+	return model?.provider === OPENAI_CODEX_PROVIDER && model.api === OPENAI_CODEX_API;
+}
+
+function getModelKey(model: Model<Api>): string {
+	return `${model.provider}:${model.api}:${model.id}`;
+}
+
+function resolveRawContextWindow<TApi extends Api>(model: Model<TApi>, state: AdapterState | undefined): number {
+	if (!state) return model.contextWindow;
+	const key = getModelKey(model);
+	const cachedRaw = state.codexContextBudgetRawWindows?.[key];
+	if (cachedRaw === undefined) {
+		state.codexContextBudgetRawWindows ??= {};
+		state.codexContextBudgetRawWindows[key] = model.contextWindow;
+		return model.contextWindow;
+	}
+
+	const cachedAdjusted = getPiContextWindowForCodexAutoCompact(cachedRaw, state.codexContextBudgetReserveTokens);
+	const previousAdjusted = state.codexContextBudgetAdjustedWindows?.[key];
+	if (model.contextWindow !== cachedRaw && model.contextWindow !== cachedAdjusted && model.contextWindow !== previousAdjusted) {
+		state.codexContextBudgetRawWindows ??= {};
+		state.codexContextBudgetRawWindows[key] = model.contextWindow;
+		delete state.codexContextBudgetAdjustedWindows?.[key];
+		return model.contextWindow;
+	}
+	return cachedRaw;
+}
+
+export function getCodexContextBudgetAdjustedModel<TApi extends Api>(model: Model<TApi>, state?: AdapterState): Model<TApi> {
+	if (!shouldUseCodexContextBudgetModel(model)) return model;
+	const rawContextWindow = resolveRawContextWindow(model, state);
+	const contextWindow = getPiContextWindowForCodexAutoCompact(rawContextWindow, state?.codexContextBudgetReserveTokens);
+	if (state) {
+		state.codexContextBudgetAdjustedWindows ??= {};
+		state.codexContextBudgetAdjustedWindows[getModelKey(model)] = contextWindow;
+	}
+	return contextWindow === model.contextWindow ? model : { ...model, contextWindow };
+}
+
+export function applyCodexContextBudgetToModel<TApi extends Api>(model: Model<TApi> | undefined, state: AdapterState): void {
+	if (!model) return;
+	state.codexContextBudgetReserveTokens ??= readPiCompactionReserveTokens(state.cwd);
+	const adjustedModel = getCodexContextBudgetAdjustedModel(model, state);
+	if (adjustedModel !== model) {
+		model.contextWindow = adjustedModel.contextWindow;
+	}
+}

package/src/adapter/compaction.ts

@@ -2,9 +2,9 @@ import type { ExtensionAPI, ExtensionContext, SessionBeforeCompactEvent } from "
 import { clampThinkingLevel, type ModelThinkingLevel, type Tool } from "@earendil-works/pi-ai";
 import { executeNativeCompaction } from "./compact-client.ts";
 import { extractCompactionSummaryText, hasCompactionOutputItem, sanitizeCompactedWindow, summarizeCompactionOutputForDiagnostics } from "./compaction-output.ts";
-import { resolveLatestNativeCompactionEntry } from "./details-store.ts";
+import { findLatestNativeCompactionEntry, findLatestNativeCompactionEntryIndex, resolveLatestNativeCompactionEntry } from "./details-store.ts";
 import { rewriteResponsesPayloadWithNativeReplay, serializeLiveTailToResponsesInput } from "./payload-rewrite.ts";
-import { resolveNativeCompactionEnvironment } from "./compaction-runtime.ts";
+import { isResponsesCompatiblePayload, resolveNativeCompactionEnvironment, type ResponsesCompatibleRequestPayload } from "./compaction-runtime.ts";
 import { convertResponsesTools } from "../providers/openai-responses-shared.ts";
 import {
 	serializeCompactionPreparationToRequest,
@@ -12,7 +12,7 @@ import {
 	type NativeCompactionRequestOptions,
 	type ResponsesInputItem,
 } from "./serializer.ts";
-import { createNativeCompactionDetails, createNativeCompactionShimResult, isNativeCompactionDetails, NATIVE_COMPACTION_SHIM_SUMMARY } from "./types.ts";
+import { createNativeCompactionDetails, createNativeCompactionShimResult, isNativeCompactionDetails, NATIVE_COMPACTION_SHIM_SUMMARY, type NativeCompactionEntry } from "./types.ts";
 import { isOpenAICodexContext, isResponsesContext } from "./codex-model.ts";
 import { shouldUseCodexAdapter } from "./activation.ts";
 import type { AdapterState } from "./state.ts";
@@ -23,6 +23,31 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+function stashLatestNativeWindowForPiCompactionFallback(
+	ctx: ExtensionContext,
+	branchEntries: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>,
+	runtime: { provider: string; api: string; baseUrl: string },
+	state: AdapterState,
+): boolean {
+	state.pendingPiCompactionNativeWindow = undefined;
+	const nativeEntry = findLatestNativeCompactionEntry(branchEntries, {
+		provider: runtime.provider,
+		api: runtime.api,
+		baseUrl: runtime.baseUrl,
+	});
+	const compactedWindow = cloneCompactedWindow(nativeEntry?.details?.compactedWindow ?? []);
+	if (!compactedWindow || compactedWindow.length === 0) return false;
+	state.pendingPiCompactionNativeWindow = {
+		window: compactedWindow,
+		provider: runtime.provider,
+		api: runtime.api,
+		baseUrl: runtime.baseUrl,
+		sessionId: ctx.sessionManager.getSessionId(),
+		sourceCompactionEntryId: nativeEntry?.id,
+	};
+	return true;
+}
+
 function cloneCompactedWindow(window: readonly unknown[]): ResponsesInputItem[] | undefined {
 	if (!window.every(isRecord)) return undefined;
 	return window.map((item) => structuredClone(item));
@@ -70,12 +95,20 @@ function clampCodexReasoningEffort(modelId: string, effort: string): string {
 	return effort;
 }
 
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+
+function clampOpenAIPromptCacheKey(key: string): string {
+	const chars = Array.from(key);
+	if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH) return key;
+	return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+}
+
 function buildCompactionRequestOptions(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState, compactionModel: string): NativeCompactionRequestOptions {
 	const tools = buildCompactionTools(pi, ctx, state);
 	const reasoning = buildCompactionReasoning(pi, ctx, state, compactionModel);
 	return {
 		parallel_tool_calls: true,
-		prompt_cache_key: ctx.sessionManager.getSessionId(),
+		prompt_cache_key: clampOpenAIPromptCacheKey(ctx.sessionManager.getSessionId()),
 		...(isOpenAICodexContext(ctx) && state.config.fast ? { service_tier: "priority" } : {}),
 		text: { verbosity: state.config.verbosity },
 		...(tools ? { tools } : {}),
@@ -94,7 +127,7 @@ function formatCompactFailureMessage(compactResult: Awaited<ReturnType<typeof ex
 	const status = compactResult.status ? ` HTTP ${compactResult.status}` : "";
 	const response = compactResult.responseText?.trim();
 	const detail = response ? `: ${response.slice(0, 500)}` : compactResult.errorMessage ? `: ${compactResult.errorMessage}` : "";
-	return `OpenAI native compaction failed (${compactResult.reason}${status})${detail}; Pi compaction was not run.`;
+	return `OpenAI native compaction failed (${compactResult.reason}${status})${detail}`;
 }
 
 function formatCompactRequestDiagnostics(request: NativeCompactionRequestBody): string {
@@ -104,6 +137,11 @@ function formatCompactRequestDiagnostics(request: NativeCompactionRequestBody):
 	return `model=${request.model}, input=${request.input.length}, tools=${tools}, reasoning=${reasoning}, service_tier=${serviceTier}`;
 }
 
+function notifyNativeCompactionFallback(ctx: ExtensionContext, state: AdapterState, branchEntries: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>, runtime: { provider: string; api: string; baseUrl: string }, message: string): void {
+	const stashed = stashLatestNativeWindowForPiCompactionFallback(ctx, branchEntries, runtime, state);
+	ctx.ui.notify(`${message}; Pi compaction will run.${stashed ? " Previous native compacted window will be included in Pi compaction fallback." : ""}`, "error");
+}
+
 export async function handleCodexSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx: ExtensionContext, state: AdapterState, pi: ExtensionAPI) {
 	if (!state.config.responsesCompaction || !shouldUseCodexAdapter(ctx, state.config)) {
 		return undefined;
@@ -203,23 +241,23 @@ async function handleCodexSessionBeforeCompactInner(event: SessionBeforeCompactE
 	const compactResult = await executeNativeCompaction({ runtime, request, signal: event.signal });
 	if (!compactResult.ok) {
 		if (compactResult.reason !== "aborted") {
-			ctx.ui.notify(formatCompactFailureMessage(compactResult), "error");
+			notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, formatCompactFailureMessage(compactResult));
 		}
-		return { cancel: true };
+		return compactResult.reason === "aborted" ? { cancel: true } : undefined;
 	}
 	const compactedWindow = sanitizeCompactedWindow(compactResult.compactedWindow);
 	if (compactedWindow.length === 0) {
-		ctx.ui.notify(`OpenAI native compaction returned no installable compacted context; Pi compaction was not run. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`, "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, `OpenAI native compaction returned no installable compacted context. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`);
+		return undefined;
 	}
 	if (!hasCompactionOutputItem(compactedWindow)) {
-		ctx.ui.notify(`OpenAI native compaction did not return a compaction item; Pi compaction was not run. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`, "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, `OpenAI native compaction did not return a compaction item. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`);
+		return undefined;
 	}
 	const encryptedSummary = extractCompactionSummaryText(compactedWindow);
 	if (!encryptedSummary) {
-		ctx.ui.notify(`OpenAI native compaction returned compacted context without a displayable summary; Pi compaction was not run. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`, "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, `OpenAI native compaction returned compacted context without a displayable summary. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`);
+		return undefined;
 	}
 	try {
 		const details = createNativeCompactionDetails({
@@ -234,8 +272,8 @@ async function handleCodexSessionBeforeCompactInner(event: SessionBeforeCompactE
 		});
 		return { compaction: createNativeCompactionShimResult({ summary: NATIVE_COMPACTION_SHIM_SUMMARY, firstKeptEntryId: event.preparation.firstKeptEntryId, tokensBefore: event.preparation.tokensBefore, details }) };
 	} catch {
-		ctx.ui.notify("OpenAI native compaction produced details Pi could not store; Pi compaction was not run.", "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, "OpenAI native compaction produced details Pi could not store");
+		return undefined;
 	}
 }
 
@@ -245,17 +283,49 @@ export async function rewriteCodexCompactedProviderRequest(payload: unknown, ctx
 	if (!resolution.ok) return undefined;
 	const runtime = resolution.runtime;
 	const branchEntries = ctx.sessionManager.getBranch();
-	const latestNativeCompaction = resolveLatestNativeCompactionEntry(branchEntries, {
+	const latestNativeCompactionIndex = findLatestNativeCompactionEntryIndex(branchEntries, {
 		provider: runtime.provider,
 		api: runtime.api,
 		baseUrl: runtime.baseUrl,
 	});
-	if (!latestNativeCompaction.ok) return undefined;
+	if (latestNativeCompactionIndex === undefined) return undefined;
 	if (!runtime.payload) return undefined;
-	const rewrite = rewriteResponsesPayloadWithNativeReplay({ model: runtime.currentModel, payload: runtime.payload, branchEntries, compactionEntry: latestNativeCompaction.entry });
+	const rewrite = rewriteResponsesPayloadWithNativeReplay({ model: runtime.currentModel, payload: runtime.payload, branchEntries, compactionEntry: branchEntries[latestNativeCompactionIndex] as NativeCompactionEntry });
 	if (rewrite.ok) return rewrite.rewrittenPayload;
 	const detail = rewrite.parity?.mismatches.slice(0, 3).join("; ");
 	const message = `OpenAI native compaction replay failed (${rewrite.reason})${detail ? `: ${detail}` : ""}; request was not sent with placeholder compaction context.`;
 	ctx.ui.notify(message, "error");
 	throw new Error(message);
 }
+
+export async function injectPendingNativeWindowIntoPiCompactionRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): Promise<unknown | undefined> {
+	const pending = state.pendingPiCompactionNativeWindow;
+	if (!pending || pending.window.length === 0) return undefined;
+	if (!isResponsesCompatiblePayload(payload)) return undefined;
+	if (pending.sessionId !== ctx.sessionManager.getSessionId()) {
+		state.pendingPiCompactionNativeWindow = undefined;
+		return undefined;
+	}
+
+	const resolution = await resolveNativeCompactionEnvironment(ctx, { enabled: true }, payload);
+	if (!resolution.ok) return undefined;
+	const runtime = resolution.runtime;
+	if (pending.provider !== runtime.provider || pending.api !== runtime.api || pending.baseUrl !== runtime.baseUrl) return undefined;
+
+	const input = [...payload.input];
+	let insertAt = 0;
+	while (insertAt < input.length) {
+		const item = input[insertAt];
+		if (!isRecord(item) || (item.role !== "system" && item.role !== "developer")) break;
+		insertAt++;
+	}
+
+	return {
+		...payload,
+		input: [
+			...input.slice(0, insertAt),
+			...pending.window.map((item) => structuredClone(item)),
+			...input.slice(insertAt),
+		],
+	};
+}

package/src/adapter/provider-request.ts

@@ -5,7 +5,7 @@ import type { AdapterState } from "./state.ts";
 import { rewriteNativeImageGenerationTool } from "../tools/image-generation-tool.ts";
 import { rewriteNativeWebSearchTool } from "../tools/web-search-tool.ts";
 import { shouldUseCodexAdapter } from "./activation.ts";
-import { rewriteCodexCompactedProviderRequest } from "./compaction.ts";
+import { injectPendingNativeWindowIntoPiCompactionRequest, rewriteCodexCompactedProviderRequest } from "./compaction.ts";
 
 export async function rewriteCodexProviderRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): Promise<unknown | undefined> {
 	if (!shouldUseCodexAdapter(ctx, state.config) || (!isOpenAICodexContext(ctx) && !isResponsesContext(ctx))) {
@@ -21,5 +21,7 @@ export async function rewriteCodexProviderRequest(payload: unknown, ctx: Extensi
 		serviceTier: isOpenAICodex,
 		verbosity: true,
 	});
+	const piCompactionPayload = await injectPendingNativeWindowIntoPiCompactionRequest(configuredPayload, ctx, state);
+	if (piCompactionPayload !== undefined) return piCompactionPayload;
 	return (await rewriteCodexCompactedProviderRequest(configuredPayload, ctx, state)) ?? configuredPayload;
 }

package/src/adapter/state.ts

@@ -1,5 +1,15 @@
 import type { PromptSkill } from "../prompt/build-system-prompt.ts";
 import type { CodexConversionConfig } from "./config.ts";
+import type { ResponsesInputItem } from "./serializer.ts";
+
+export interface PendingPiCompactionNativeWindow {
+	window: ResponsesInputItem[];
+	provider: string;
+	api: string;
+	baseUrl: string;
+	sessionId: string;
+	sourceCompactionEntryId?: string;
+}
 
 export interface AdapterState {
 	enabled: boolean;
@@ -8,4 +18,8 @@ export interface AdapterState {
 	previousToolNames?: string[];
 	promptSkills: PromptSkill[];
 	config: CodexConversionConfig;
+	pendingPiCompactionNativeWindow?: PendingPiCompactionNativeWindow;
+	codexContextBudgetRawWindows?: Record<string, number>;
+	codexContextBudgetAdjustedWindows?: Record<string, number>;
+	codexContextBudgetReserveTokens?: number;
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
 import { Box, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { getCodexRuntimeShell } from "./adapter/runtime-shell.ts";
 import { clearApplyPatchRenderState, registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
@@ -22,6 +23,7 @@ import { getCodexSkillPaths, hasNoSkillsFlag } from "./adapter/skills.ts";
 import type { AdapterState } from "./adapter/state.ts";
 import { registerCodexCommand } from "./codex-settings/command.ts";
 import { WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
+import { applyCodexContextBudgetToModel, readPiCompactionReserveTokens } from "./adapter/codex-context-budget.ts";
 
 function getCommandArg(args: unknown): string | undefined {
 	if (!args || typeof args !== "object" || !("cmd" in args) || typeof args.cmd !== "string") {
@@ -62,6 +64,10 @@ export default function codexConversion(pi: ExtensionAPI) {
 		}
 	}
 
+	function ensureCodexContextBudgetModel(ctx: { model: Model<any> | undefined }): void {
+		applyCodexContextBudgetToModel(ctx.model, state);
+	}
+
 	registerOpenAICodexCustomProvider(pi, {
 		getCurrentCwd: () => state.cwd,
 		getNativeToolRewriteConfig: () => ({
@@ -92,6 +98,8 @@ export default function codexConversion(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		state.cwd = ctx.cwd;
 		state.config = readCodexConversionConfig();
+		state.codexContextBudgetReserveTokens = readPiCompactionReserveTokens(ctx.cwd);
+		ensureCodexContextBudgetModel(ctx);
 		ensureOptionalNativeToolsRegistered();
 		state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
 		registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
@@ -108,6 +116,8 @@ export default function codexConversion(pi: ExtensionAPI) {
 
 	pi.on("model_select", async (_event, ctx) => {
 		state.cwd = ctx.cwd;
+		state.codexContextBudgetReserveTokens = readPiCompactionReserveTokens(ctx.cwd);
+		ensureCodexContextBudgetModel(ctx);
 		state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
 		registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
 		syncAdapter(pi, ctx, state);
@@ -163,6 +173,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 
 	pi.on("session_compact", async (event) => {
+		state.pendingPiCompactionNativeWindow = undefined;
 		if (!event.fromExtension || !isNativeCompactionDetails(event.compactionEntry.details)) return;
 		pi.sendMessage(
 			{

package/src/providers/openai-codex-custom-provider.ts

@@ -37,6 +37,14 @@ const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
 const dynamicImport = (specifier: string) => import(specifier);
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+
+function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined {
+	if (key === undefined) return undefined;
+	const chars = Array.from(key);
+	if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH) return key;
+	return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+}
 let _os: { platform(): string; release(): string; arch(): string } | null = null;
 
 if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
@@ -87,6 +95,7 @@ interface QueuedWebSearchActivity {
 }
 
 type PendingActivity = QueuedImageActivity | QueuedWebSearchActivity;
+type SendActivityMessage = ExtensionAPI["sendMessage"];
 
 interface CachedImagePreview {
 	data: string;
@@ -577,7 +586,7 @@ export function buildRequestBody<TApi extends Api>(model: Model<TApi>, context:
 		input: messages,
 		text: { verbosity: ((options as { textVerbosity?: string } | undefined)?.textVerbosity ?? "low") as string },
 		include: ["reasoning.encrypted_content"],
-		prompt_cache_key: options?.sessionId,
+		prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
 		tool_choice: "auto",
 		parallel_tool_calls: true,
 	};
@@ -1449,6 +1458,87 @@ export function buildWebSearchSummaryText(searches: SurfacedWebSearch[]): string
 	return searches.length === 1 ? "Searched the web once" : `Searched the web ${searches.length} times`;
 }
 
+function sendActivityMessages(
+	sendMessage: SendActivityMessage,
+	imagePreviewCache: Map<string, CachedImagePreview>,
+	activities: PendingActivity[],
+): void {
+	for (let index = 0; index < activities.length; index++) {
+		const activity = activities[index];
+		if (activity.kind === "image") {
+			imagePreviewCache.set(activity.savedImage.absolutePath, activity.imageData);
+			sendMessage(
+				{
+					customType: IMAGE_SAVE_DISPLAY_MESSAGE_TYPE,
+					content: [{ type: "text", text: buildGeneratedImageDisplayText(activity.savedImage, { expanded: false }) }],
+					display: true,
+					details: { savedImages: [activity.savedImage] } satisfies ImageDisplayMessageDetails,
+				},
+				{ triggerTurn: false },
+			);
+			continue;
+		}
+
+		const searches = [activity.search];
+		while (index + 1 < activities.length && activities[index + 1]?.kind === "web-search") {
+			searches.push((activities[++index] as QueuedWebSearchActivity).search);
+		}
+		sendMessage(
+			{
+				customType: WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
+				content: buildWebSearchActivityMessage(searches),
+				display: true,
+				details: { searches },
+			},
+			{ triggerTurn: false },
+		);
+	}
+}
+
+export function createActivityMessageDispatcher(sendMessage: SendActivityMessage): {
+	imagePreviewCache: Map<string, CachedImagePreview>;
+	enqueueSettledActivities(activities: PendingActivity[]): void;
+	flushNow(): void;
+	scheduleFlush(): void;
+	clear(): void;
+} {
+	const completedActivities: PendingActivity[] = [];
+	const imagePreviewCache = new Map<string, CachedImagePreview>();
+	let pendingFlushTimer: ReturnType<typeof setTimeout> | undefined;
+
+	const flush = () => {
+		pendingFlushTimer = undefined;
+		const activities = completedActivities.splice(0, completedActivities.length);
+		if (activities.length > 0) sendActivityMessages(sendMessage, imagePreviewCache, activities);
+	};
+
+	return {
+		imagePreviewCache,
+		enqueueSettledActivities(activities) {
+			completedActivities.push(...activities);
+		},
+		flushNow() {
+			if (pendingFlushTimer) {
+				clearTimeout(pendingFlushTimer);
+				pendingFlushTimer = undefined;
+			}
+			flush();
+		},
+		scheduleFlush() {
+			if (pendingFlushTimer || completedActivities.length === 0) return;
+			pendingFlushTimer = setTimeout(flush, 0);
+		},
+		clear() {
+			if (pendingFlushTimer) {
+				clearTimeout(pendingFlushTimer);
+				pendingFlushTimer = undefined;
+			}
+			completedActivities.length = 0;
+			imagePreviewCache.clear();
+		},
+	};
+}
+
 function loadCachedImagePreview(savedImage: SavedGeneratedImage, imagePreviewCache: Map<string, CachedImagePreview>): CachedImagePreview | undefined {
 	const cached = imagePreviewCache.get(savedImage.absolutePath);
 	if (cached) return cached;
@@ -1543,6 +1633,7 @@ function createCodexStream<TApi extends Api>(
 		getNativeToolRewriteConfig?: () => { webSearch: boolean; imageGeneration: boolean };
 		onImageSaved?: (savedImage: SavedGeneratedImage, imageData: { data: string; mimeType: string }) => void;
 		onWebSearchCaptured?: (search: SurfacedWebSearch) => void;
+		onStreamSettled?: () => void;
 	},
 ): AssistantMessageEventStream {
 	const stream = createAssistantMessageEventStream();
@@ -1696,6 +1787,8 @@ function createCodexStream<TApi extends Api>(
 				error: createErrorMessage(output, error, !!options?.signal?.aborted),
 			});
 			stream.end();
+		} finally {
+			deps.onStreamSettled?.();
 		}
 	})();
 
@@ -1703,75 +1796,31 @@ function createCodexStream<TApi extends Api>(
 }
 
 export function registerOpenAICodexCustomProvider(pi: ExtensionAPI, options: { getCurrentCwd: () => string; getNativeToolRewriteConfig?: () => { webSearch: boolean; imageGeneration: boolean } }): void {
-	const pendingActivities: PendingActivity[] = [];
-	const imagePreviewCache = new Map<string, CachedImagePreview>();
-	let pendingFlushTimer: ReturnType<typeof setTimeout> | undefined;
-
-	const flushPendingMessages = () => {
-		pendingFlushTimer = undefined;
-		const activities = pendingActivities.splice(0, pendingActivities.length);
-
-		for (let index = 0; index < activities.length; index++) {
-			const activity = activities[index];
-			if (activity.kind === "image") {
-				imagePreviewCache.set(activity.savedImage.absolutePath, activity.imageData);
-				pi.sendMessage(
-					{
-						customType: IMAGE_SAVE_DISPLAY_MESSAGE_TYPE,
-						content: [{ type: "text", text: buildGeneratedImageDisplayText(activity.savedImage, { expanded: false }) }],
-						display: true,
-						details: { savedImages: [activity.savedImage] } satisfies ImageDisplayMessageDetails,
-					},
-					{ triggerTurn: false },
-				);
-				continue;
-			}
-
-			const searches = [activity.search];
-			while (index + 1 < activities.length && activities[index + 1]?.kind === "web-search") {
-				searches.push((activities[++index] as QueuedWebSearchActivity).search);
-			}
-			pi.sendMessage(
-				{
-					customType: WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
-					content: buildWebSearchActivityMessage(searches),
-					display: true,
-					details: { searches },
-				},
-				{ triggerTurn: false },
-			);
-		}
-	};
-
-	const schedulePendingMessageFlush = () => {
-		if (pendingFlushTimer || pendingActivities.length === 0) {
-			return;
-		}
-		pendingFlushTimer = setTimeout(flushPendingMessages, 0);
-	};
+	const activityDispatcher = createActivityMessageDispatcher(pi.sendMessage.bind(pi));
 
 	const clearPendingMessages = () => {
-		if (pendingFlushTimer) {
-			clearTimeout(pendingFlushTimer);
-			pendingFlushTimer = undefined;
-		}
-		pendingActivities.length = 0;
-		imagePreviewCache.clear();
+		activityDispatcher.clear();
 	};
 
 	pi.registerProvider("openai-codex", {
 		api: "openai-codex-responses",
-		streamSimple: (model, context, streamOptions) =>
-			createCodexStream(model, context, streamOptions, {
+		streamSimple: (model, context, streamOptions) => {
+			const turnActivities: PendingActivity[] = [];
+			return createCodexStream(model, context, streamOptions, {
 				getCurrentCwd: options.getCurrentCwd,
 				getNativeToolRewriteConfig: options.getNativeToolRewriteConfig,
 				onImageSaved: (savedImage, imageData) => {
-					pendingActivities.push({ kind: "image", savedImage, imageData });
+					turnActivities.push({ kind: "image", savedImage, imageData });
 				},
 				onWebSearchCaptured: (search) => {
-					pendingActivities.push({ kind: "web-search", search });
+					turnActivities.push({ kind: "web-search", search });
+				},
+				onStreamSettled: () => {
+					const activities = turnActivities.splice(0, turnActivities.length);
+					if (activities.length > 0) activityDispatcher.enqueueSettledActivities(activities);
 				},
-			}),
+			});
+		},
 	});
 
 	pi.on("session_start", async () => {
@@ -1779,15 +1828,13 @@ export function registerOpenAICodexCustomProvider(pi: ExtensionAPI, options: { g
 	});
 
 	pi.on("session_shutdown", async () => {
-		if (pendingActivities.length > 0) {
-			flushPendingMessages();
-		}
+		activityDispatcher.flushNow();
 		clearPendingMessages();
 		closeOpenAICodexWebSocketSessions();
 	});
 
 	pi.on("agent_end", async () => {
-		schedulePendingMessageFlush();
+		activityDispatcher.scheduleFlush();
 	});
 
 	pi.registerMessageRenderer<ImageDisplayMessageDetails>(IMAGE_SAVE_DISPLAY_MESSAGE_TYPE, (message, options, theme) => {
@@ -1804,7 +1851,7 @@ export function registerOpenAICodexCustomProvider(pi: ExtensionAPI, options: { g
 						.join("\n");
 		box.addChild(new Text(`\n${theme.fg("customMessageText", textContent)}`, 0, 0));
 		if (savedImage) {
-			const preview = loadCachedImagePreview(savedImage, imagePreviewCache);
+			const preview = loadCachedImagePreview(savedImage, activityDispatcher.imagePreviewCache);
 			if (preview) {
 				box.addChild(new Spacer(1));
 				box.addChild(