@howaboua/pi-codex-conversion 1.5.10 → 1.5.11-dev.46.3146d2f

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.5.11
+
+- Aligned the custom OpenAI Codex provider and Pi development dependencies with Pi 0.75.4.
+- Added Codex context-budget alignment so Pi auto-compaction for OpenAI Codex subscription models triggers near Codex's native 90% compacting threshold.
+- Improved native Responses compaction fallback: failed native compactions now fall back to Pi compaction, and reuse the previous native compacted window when available.
+- Pruned low-value compatibility tests while keeping focused coverage for adapter activation, native tools, compaction fallback, and Codex context budgeting.
+
 ## 1.5.10
 
 - Added `/codex usage` and a Usage tab for OpenAI Codex subscription limits, with automatic refresh and aligned 5-hour/weekly usage columns.

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",
+  "version": "1.5.11-dev.46.3146d2f",
   "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,33 @@ 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");
+}
+
+function textFromResponsesContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((item) => isRecord(item) && item.type === "input_text" && typeof item.text === "string" ? item.text : "")
+		.join("\n");
+}
+
+function isPiCompactionSummarizationPayload(payload: ResponsesCompatibleRequestPayload): boolean {
+	const instructions = typeof payload.instructions === "string" ? payload.instructions : "";
+	if (/compact|summar/i.test(instructions)) return true;
+
+	return payload.input.some((item) => {
+		if (!isRecord(item)) return false;
+		const role = item.role;
+		const text = textFromResponsesContent(item.content);
+		if ((role === "system" || role === "developer") && /compact|summar/i.test(text)) return true;
+		if (role === "user" && /<conversation>|previous compaction summary|summary/i.test(text)) return true;
+		return false;
+	});
+}
+
 export async function handleCodexSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx: ExtensionContext, state: AdapterState, pi: ExtensionAPI) {
 	if (!state.config.responsesCompaction || !shouldUseCodexAdapter(ctx, state.config)) {
 		return undefined;
@@ -127,6 +187,9 @@ async function handleCodexSessionBeforeCompactInner(event: SessionBeforeCompactE
 
 	const resolution = await resolveNativeCompactionEnvironment(ctx, { enabled: true });
 	if (!resolution.ok) {
+		if (resolution.reason === "unsupported-provider" || resolution.reason === "unsupported-api") {
+			return undefined;
+		}
 		ctx.ui.notify(`OpenAI native compaction is enabled but unavailable (${resolution.reason}); Pi compaction was not run.`, "error");
 		return { cancel: true };
 	}
@@ -203,23 +266,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 +297,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 +308,54 @@ 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;
+	}
+	if (!isPiCompactionSummarizationPayload(payload)) 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) {
+		state.pendingPiCompactionNativeWindow = undefined;
+		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++;
+	}
+
+	state.pendingPiCompactionNativeWindow = undefined;
+	return {
+		...payload,
+		input: [
+			...input.slice(0, insertAt),
+			...pending.window.map((item) => structuredClone(item)),
+			...input.slice(insertAt),
+		],
+	};
+}

package/src/adapter/payload-rewrite.ts

@@ -390,6 +390,15 @@ function createReplayVariants<TApi extends Api>(args: {
 	return [contextSet, createReplayMessageSet(args.model, piMessages)];
 }
 
+function clonePayloadConversationInput(args: {
+	payloadInput: readonly unknown[];
+	freshPreamble: FreshAuthoritativePreamble;
+}): ResponsesInputItem[] | undefined {
+	const tailEndIndex = args.payloadInput.length - args.freshPreamble.trailingInput.length;
+	if (tailEndIndex < args.freshPreamble.leadingInput.length) return undefined;
+	return cloneResponsesInputSlice(args.payloadInput.slice(args.freshPreamble.leadingInput.length, tailEndIndex));
+}
+
 function findReplayMatch<TApi extends Api>(args: {
 	model: Model<TApi>;
 	payloadInput: readonly unknown[];
@@ -506,21 +515,57 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		};
 	}
 
-	const newerCompactionEntry = args.branchEntries
-		.slice(boundaryIndex + 1)
-		.some((entry) => entry.type === "compaction");
-	if (newerCompactionEntry) {
+	const compactedWindow = cloneOpaqueCompactedWindow(args.compactionEntry.details?.compactedWindow ?? []);
+	if (!compactedWindow) {
 		return {
 			ok: false,
-			reason: "unexpected-compaction-after-boundary",
+			reason: "invalid-compacted-window",
 		};
 	}
 
-	const compactedWindow = cloneOpaqueCompactedWindow(args.compactionEntry.details?.compactedWindow ?? []);
-	if (!compactedWindow) {
+	const newerCompactionEntry = args.branchEntries
+		.slice(boundaryIndex + 1)
+		.some((entry) => entry.type === "compaction");
+	if (newerCompactionEntry) {
+		const conversationInput = clonePayloadConversationInput({ payloadInput: args.payload.input, freshPreamble });
+		const originalPiReplayInput = cloneResponsesInputSlice(args.payload.input);
+		if (!conversationInput || !originalPiReplayInput) {
+			return {
+				ok: false,
+				reason: "unexpected-compaction-after-boundary",
+			};
+		}
+
 		return {
-			ok: false,
-			reason: "invalid-compacted-window",
+			ok: true,
+			segments: {
+				boundaryIndex,
+				firstKeptEntryIndex,
+				instructions: freshPreamble.instructions,
+				freshPreamble: freshPreamble.leadingInput,
+				trailingPreamble: freshPreamble.trailingInput,
+				compactionSummary: [],
+				preCompactionKeptWindow: createReplaySlice([], [], []),
+				compactedWindow,
+				postCompactionTail: createReplaySlice(args.branchEntries.slice(boundaryIndex + 1), [], conversationInput),
+				originalPiReplayInput,
+				replayInput: [
+					...freshPreamble.leadingInput,
+					...compactedWindow,
+					...conversationInput,
+					...freshPreamble.trailingInput,
+				],
+			},
+			rewrittenPayload: {
+				...args.payload,
+				...(freshPreamble.instructions !== undefined ? { instructions: freshPreamble.instructions } : {}),
+				input: [
+					...freshPreamble.leadingInput,
+					...compactedWindow,
+					...conversationInput,
+					...freshPreamble.trailingInput,
+				],
+			},
 		};
 	}
 

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/adapter/types.ts

@@ -9,7 +9,7 @@ export const NATIVE_COMPACTION_DISPLAY_TEXT = [
 	"",
 	"The compaction result is encrypted by OpenAI and is not human-readable in Pi.",
 	"",
-	"Warning: do not turn Responses compaction off mid-session; old context may be much less reliable.",
+	"Warning: do not turn Responses compaction off or switch providers mid-session; old context may be much less reliable.",
 ].join("\n");
 
 export type NativeCompactionStrategy = typeof NATIVE_COMPACTION_STRATEGY;

package/src/codex-settings/ui.ts

@@ -92,7 +92,8 @@ export async function openCodexSettingsScreen(ctx: ExtensionContext, options: Co
 function formatCompactionNotes(theme: Theme): string[] {
 	return [
 		theme.fg("dim", "  Beta: native OpenAI Responses compaction is experimental. Please report any issues."),
-		theme.fg("error", "  Warning: do not turn this off mid-session; old context may be much less reliable."),
+		theme.fg("error", "  Warning: do not turn this off or switch providers mid-session; old context may be much less reliable."),
+		theme.fg("warning", "  If native compaction recovery fails, go back below 90% context and compact from there."),
 	];
 }
 

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(