@oh-my-pi/pi-agent-core 16.2.2 → 16.2.3

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [16.2.3] - 2026-06-28
+
+### Changed
+
+- Enabled V2 streaming remote compaction by default for compatible AI and OpenAI-compatible models, which forwards full conversation history to the provider and supports session routing, prompt caching, provider-native tool history replay, transient error retries, and configurable timeouts.
+
+### Fixed
+
+- Fixed an issue where assistant responses and encrypted reasoning could be lost during local history trimming.
+- Added `title_change` session metadata to the compaction entry type union to maintain type compatibility for hosts with title audit entries.
+
 ## [16.2.2] - 2026-06-27
 
 ### Added

package/dist/types/compaction/compaction-v2-streaming.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Remote Compaction V2: streaming Responses compaction.
+ *
+ * Mirrors Codex `core/src/compact_remote_v2.rs`: append a `compaction_trigger`
+ * input item to the normal Responses stream, require exactly one streamed
+ * compaction output item, then install retained real user messages plus that
+ * compaction item as replacement history.
+ */
+import type { FetchImpl, Model } from "@oh-my-pi/pi-ai";
+/** Retained-message budget Codex uses after streamed V2 compaction. */
+export declare const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64000;
+/** Max retries for V2 streaming compaction on transient stream errors. */
+export declare const V2_COMPACTION_MAX_RETRIES = 2;
+/** Timeout for V2 streaming compaction (3 minutes, same as V1). */
+export declare const V2_COMPACTION_TIMEOUT_MS = 180000;
+/** Token usage reported by the streamed V2 Responses completion. */
+export interface CompactionV2Usage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens?: number;
+    reasoningOutputTokens?: number;
+}
+/** Request body fields needed for Responses-stream V2 compaction. */
+export interface CompactionV2Request {
+    model: string;
+    input: unknown[];
+    instructions: string;
+    retainedMessageBudget: number;
+    tools?: unknown[];
+    /** Responses reasoning param (effort + summary), matching a normal turn; omitted for non-reasoning models. */
+    reasoning?: {
+        effort: string;
+        summary: string;
+    };
+    sessionId?: string;
+    promptCacheKey?: string;
+}
+/** Response collected from the V2 stream and converted into replacement history. */
+export interface CompactionV2Response {
+    compactionItem: Record<string, unknown>;
+    replacementHistory: Array<Record<string, unknown>>;
+    usedTokens: number;
+    usage?: CompactionV2Usage;
+    retainedImageCount: number;
+}
+/** Resolve the streaming Responses endpoint for a V2-capable model. */
+export declare function getCompactionV2Endpoint(model: Model): string | undefined;
+/** Check whether a model can use streaming V2 compaction. */
+export declare function shouldUseCompactionV2Streaming(model: Model): model is Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">;
+/** Clamp the retained-message budget to Codex's known-safe 64K ceiling. */
+export declare function resolveCompactionV2RetainedMessageBudget(value: number | undefined): number;
+/** Build a V2 streaming compaction request from Responses-native history. */
+export declare function buildCompactionV2Request(model: Model, input: unknown[], instructions: string, options?: {
+    tools?: unknown[];
+    reasoning?: {
+        effort: string;
+        summary: string;
+    };
+    sessionId?: string;
+    promptCacheKey?: string;
+    retainedMessageBudget?: number;
+}): CompactionV2Request;
+/** Request V2 compaction over the normal OpenAI Responses streaming endpoint. */
+export declare function requestCompactionV2Streaming(model: Model, apiKey: string, request: CompactionV2Request, signal?: AbortSignal, options?: {
+    fetch?: FetchImpl;
+    timeoutMs?: number;
+    retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+}): Promise<CompactionV2Response>;
+/** Build Codex-style V2 replacement history from prompt input plus compaction output. */
+export declare function buildCompactionV2ReplacementHistory(input: unknown[], compactionItem: Record<string, unknown>, retainedMessageBudget?: number): {
+    replacementHistory: Array<Record<string, unknown>>;
+    retainedImageCount: number;
+};
+/** Store V2 replacement history in the OpenAI remote-compaction preserve slot. */
+export declare function storeCompactionV2PreserveData(response: CompactionV2Response, model: Model): Record<string, unknown>;
+/** Retrieve preserved OpenAI replacement history that V2 can extend. */
+export declare function getCompactionV2PreserveData(preserveData: Record<string, unknown> | undefined): {
+    provider: string;
+    replacementHistory: Array<Record<string, unknown>>;
+    usedTokens: number;
+} | undefined;

package/dist/types/compaction/compaction.d.ts

@@ -39,6 +39,8 @@ export interface CompactionSettings {
     autoContinue?: boolean;
     remoteEnabled?: boolean;
     remoteEndpoint?: string;
+    remoteStreamingV2Enabled?: boolean;
+    v2RetainedMessageBudget?: number;
 }
 export declare const DEFAULT_COMPACTION_SETTINGS: CompactionSettings;
 /**
@@ -151,6 +153,12 @@ export interface SummaryOptions {
      * `resolveCompactionEffort` for the conversion contract.
      */
     thinkingLevel?: ThinkingLevel;
+    /** Session routing key for remote compaction transports with sticky provider sessions. */
+    sessionId?: string;
+    /** Prompt-cache key for remote compaction transports that support provider prefix caching. */
+    promptCacheKey?: string;
+    /** Provider-visible tools for remote compaction transports that replay native tool history. */
+    tools?: Tool[];
     /** Optional fetch implementation threaded into remote compaction calls. */
     fetch?: FetchImpl;
 }
@@ -229,7 +237,7 @@ export interface CompactionPreparation {
     /** Compaction settions from settings.jsonl	*/
     settings: CompactionSettings;
 }
-export declare function prepareCompaction(pathEntries: SessionEntry[], settings: CompactionSettings): CompactionPreparation | undefined;
+export declare function prepareCompaction(pathEntries: SessionEntry[], settings: CompactionSettings, compactionModels?: readonly Model[]): CompactionPreparation | undefined;
 /**
  * Generate summaries for compaction using prepared data.
  * Returns CompactionResult - SessionManager adds id/parentId when saving.

package/dist/types/compaction/entries.d.ts

@@ -66,6 +66,13 @@ export interface LabelEntry extends SessionEntryBase {
     targetId: string;
     label: string | undefined;
 }
+export interface TitleChangeEntry extends SessionEntryBase {
+    type: "title_change";
+    title: string;
+    previousTitle?: string;
+    source: "auto" | "user";
+    trigger?: string;
+}
 export interface TtsrInjectionEntry extends SessionEntryBase {
     type: "ttsr_injection";
     /** Names of rules that were injected */
@@ -96,7 +103,7 @@ export interface ModeChangeEntry extends SessionEntryBase {
 }
 export interface CustomCompactionSessionEntries {
 }
-export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry | CustomCompactionSessionEntries[keyof CustomCompactionSessionEntries];
+export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TitleChangeEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry | CustomCompactionSessionEntries[keyof CustomCompactionSessionEntries];
 export interface ReadonlySessionManager {
     getBranch(leafId?: string | null): SessionEntry[];
     getEntry(id: string): SessionEntry | undefined;

package/dist/types/compaction/openai.d.ts

@@ -1,9 +1,12 @@
 /**
  * Remote compaction utilities.
  *
- * Provider-side conversation summarization endpoints. Two flavors:
+ * Provider-side conversation summarization endpoints. Three flavors:
  *
- * - **OpenAI remote compaction** (`/responses/compact`): preserves encrypted
+ * - **OpenAI remote compaction V2** (Responses streaming): appends a
+ *   `compaction_trigger` input item to the normal stream and stores the returned
+ *   `compaction` item with retained real user messages in `preserveData`.
+ * - **OpenAI remote compaction V1** (`/responses/compact`): preserves encrypted
  *   reasoning across compactions by submitting the full responses-API native
  *   history and storing the returned `compaction` / `compaction_summary`
  *   item in `preserveData` so future turns can replay the encrypted state.
@@ -12,6 +15,7 @@
  *   with `{ summary, shortSummary? }`.
  */
 import type { FetchImpl, Message, Model } from "@oh-my-pi/pi-ai/types";
+export * from "./compaction-v2-streaming";
 export declare const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
 /**
  * Hard ceiling on remote compaction HTTP requests. Unlike every provider

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "16.2.2",
+	"version": "16.2.3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -35,12 +35,12 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "16.2.2",
-		"@oh-my-pi/pi-catalog": "16.2.2",
-		"@oh-my-pi/pi-natives": "16.2.2",
-		"@oh-my-pi/pi-utils": "16.2.2",
-		"@oh-my-pi/pi-wire": "16.2.2",
-		"@oh-my-pi/snapcompact": "16.2.2",
+		"@oh-my-pi/pi-ai": "16.2.3",
+		"@oh-my-pi/pi-catalog": "16.2.3",
+		"@oh-my-pi/pi-natives": "16.2.3",
+		"@oh-my-pi/pi-utils": "16.2.3",
+		"@oh-my-pi/pi-wire": "16.2.3",
+		"@oh-my-pi/snapcompact": "16.2.3",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {

package/src/compaction/compaction-v2-streaming.ts

@@ -0,0 +1,724 @@
+/**
+ * Remote Compaction V2: streaming Responses compaction.
+ *
+ * Mirrors Codex `core/src/compact_remote_v2.rs`: append a `compaction_trigger`
+ * input item to the normal Responses stream, require exactly one streamed
+ * compaction output item, then install retained real user messages plus that
+ * compaction item as replacement history.
+ */
+
+import type { Api, FetchImpl, Model } from "@oh-my-pi/pi-ai";
+import { isTransientStatus, ProviderHttpError } from "@oh-my-pi/pi-ai/error";
+import {
+	getOpenAIResponsesPromptCacheKey,
+	getOpenAIResponsesRoutingSessionId,
+	parseAzureDeploymentNameMap,
+	resolveOpenAIRequestSetup,
+} from "@oh-my-pi/pi-ai/providers/openai-shared";
+import {
+	CODEX_BASE_URL,
+	getCodexAccountId,
+	OPENAI_HEADER_VALUES,
+	OPENAI_HEADERS,
+} from "@oh-my-pi/pi-catalog/wire/codex";
+import { $env, logger } from "@oh-my-pi/pi-utils";
+
+// ============================================================================
+// Types & Configuration
+// ============================================================================
+
+/** Retained-message budget Codex uses after streamed V2 compaction. */
+export const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
+
+/** Max retries for V2 streaming compaction on transient stream errors. */
+export const V2_COMPACTION_MAX_RETRIES = 2;
+
+/** Timeout for V2 streaming compaction (3 minutes, same as V1). */
+export const V2_COMPACTION_TIMEOUT_MS = 180_000;
+
+const DEFAULT_AZURE_API_VERSION = "v1";
+const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
+const COMPACTION_TRIGGER_ITEM = { type: "compaction_trigger" } as const;
+// OpenAI image metering depends on detail and dimensions; charge the common
+// high-detail 1024px-path budget so retained image history cannot be unbounded.
+const IMAGE_TOKEN_ESTIMATE = 765;
+const CONTEXTUAL_USER_PREFIXES = [
+	"<environment_context>",
+	"<user_instructions>",
+	"<additional_context>",
+	"<skills",
+	"<token_budget>",
+	"<model_switch>",
+];
+
+/** Token usage reported by the streamed V2 Responses completion. */
+export interface CompactionV2Usage {
+	inputTokens: number;
+	outputTokens: number;
+	totalTokens: number;
+	cachedInputTokens?: number;
+	reasoningOutputTokens?: number;
+}
+
+/** Request body fields needed for Responses-stream V2 compaction. */
+export interface CompactionV2Request {
+	model: string;
+	input: unknown[];
+	instructions: string;
+	retainedMessageBudget: number;
+	tools?: unknown[];
+	/** Responses reasoning param (effort + summary), matching a normal turn; omitted for non-reasoning models. */
+	reasoning?: { effort: string; summary: string };
+	sessionId?: string;
+	promptCacheKey?: string;
+}
+
+/** Response collected from the V2 stream and converted into replacement history. */
+export interface CompactionV2Response {
+	compactionItem: Record<string, unknown>;
+	replacementHistory: Array<Record<string, unknown>>;
+	usedTokens: number;
+	usage?: CompactionV2Usage;
+	retainedImageCount: number;
+}
+
+// ============================================================================
+// Endpoint Resolution
+// ============================================================================
+
+/** Resolve the streaming Responses endpoint for a V2-capable model. */
+export function getCompactionV2Endpoint(model: Model): string | undefined {
+	if (model.remoteCompaction?.enabled === false) return undefined;
+	if (!isOpenAiV2CompatibleModel(model)) return undefined;
+
+	const configuredEndpoint = model.remoteCompaction?.v2Endpoint ?? model.remoteCompaction?.streamingEndpoint;
+	if (configuredEndpoint && configuredEndpoint.length > 0) return configuredEndpoint;
+
+	const api = compactionV2Api(model);
+	if (api === "azure-openai-responses") {
+		return appendAzureApiVersion(`${resolveAzureOpenAiBaseUrl(model)}/responses`);
+	}
+	if (api === "openai-codex-responses" || model.provider === "openai-codex") {
+		return resolveOpenAiCodexResponsesEndpoint(model.baseUrl);
+	}
+	return resolveOpenAiResponsesEndpoint(model.baseUrl);
+}
+
+/** Check whether a model can use streaming V2 compaction. */
+export function shouldUseCompactionV2Streaming(
+	model: Model,
+): model is Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses"> {
+	if (model.remoteCompaction?.v2StreamingEnabled !== true) return false;
+	return getCompactionV2Endpoint(model) !== undefined;
+}
+
+function compactionV2Api(model: Model): Api | undefined {
+	return model.remoteCompaction?.api ?? model.api;
+}
+
+function isOpenAiV2CompatibleModel(model: Model): boolean {
+	const api = compactionV2Api(model);
+	return api === "openai-responses" || api === "azure-openai-responses" || api === "openai-codex-responses";
+}
+
+function resolveOpenAiResponsesEndpoint(baseUrl: string | undefined): string {
+	const rawBase = baseUrl && baseUrl.length > 0 ? baseUrl : "https://api.openai.com/v1";
+	const normalizedBase = rawBase.replace(/\/+$/, "");
+	if (normalizedBase.endsWith("/responses")) return normalizedBase;
+	if (normalizedBase.endsWith("/v1")) return `${normalizedBase}/responses`;
+	return `${normalizedBase}/v1/responses`;
+}
+
+function resolveOpenAiCodexResponsesEndpoint(baseUrl: string | undefined): string {
+	const rawBase = baseUrl && baseUrl.trim().length > 0 ? baseUrl : CODEX_BASE_URL;
+	const normalizedBase = rawBase.replace(/\/+$/, "");
+	if (normalizedBase.endsWith("/codex/responses")) return normalizedBase;
+	if (normalizedBase.endsWith("/codex")) return `${normalizedBase}/responses`;
+	return `${normalizedBase}/codex/responses`;
+}
+
+function resolveAzureOpenAiBaseUrl(model: Model): string {
+	const baseUrl = $env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
+	const resourceName = $env.AZURE_OPENAI_RESOURCE_NAME;
+	const resolvedBaseUrl =
+		baseUrl ?? (resourceName ? `https://${resourceName}.openai.azure.com/openai/v1` : undefined) ?? model.baseUrl;
+	if (!resolvedBaseUrl) {
+		throw new Error(
+			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or configure model.baseUrl.",
+		);
+	}
+	return resolvedBaseUrl.replace(/\/+$/, "");
+}
+
+function appendAzureApiVersion(endpoint: string): string {
+	if (/[?&]api-version=/.test(endpoint)) return endpoint;
+	const separator = endpoint.includes("?") ? "&" : "?";
+	return `${endpoint}${separator}api-version=${encodeURIComponent($env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION)}`;
+}
+
+function resolveCompactionV2Model(model: Model): string {
+	const requestModel = model.remoteCompaction?.model ?? model.requestModelId ?? model.id;
+	if (compactionV2Api(model) !== "azure-openai-responses") return requestModel;
+	const mappedDeployment = parseAzureDeploymentNameMap($env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(requestModel);
+	return mappedDeployment ?? requestModel;
+}
+
+// ============================================================================
+// Request Building
+// ============================================================================
+
+/** Clamp the retained-message budget to Codex's known-safe 64K ceiling. */
+export function resolveCompactionV2RetainedMessageBudget(value: number | undefined): number {
+	if (value === undefined || !Number.isFinite(value)) return V2_RETAINED_MESSAGE_TOKEN_BUDGET;
+	return Math.min(V2_RETAINED_MESSAGE_TOKEN_BUDGET, Math.max(1, Math.floor(value)));
+}
+
+/** Build a V2 streaming compaction request from Responses-native history. */
+export function buildCompactionV2Request(
+	model: Model,
+	input: unknown[],
+	instructions: string,
+	options?: {
+		tools?: unknown[];
+		reasoning?: { effort: string; summary: string };
+		sessionId?: string;
+		promptCacheKey?: string;
+		retainedMessageBudget?: number;
+	},
+): CompactionV2Request {
+	return {
+		model: resolveCompactionV2Model(model),
+		input,
+		instructions,
+		retainedMessageBudget: resolveCompactionV2RetainedMessageBudget(options?.retainedMessageBudget),
+		reasoning: options?.reasoning,
+		tools: options?.tools,
+		sessionId: options?.sessionId,
+		promptCacheKey: options?.promptCacheKey,
+	};
+}
+
+// ============================================================================
+// Streaming Request Handler
+// ============================================================================
+
+/** Race the caller's signal against the V2 request timeout. */
+function withRequestTimeout(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal | undefined {
+	if (timeoutMs <= 0) return signal;
+	const timeout = AbortSignal.timeout(timeoutMs);
+	return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+/** Request V2 compaction over the normal OpenAI Responses streaming endpoint. */
+export async function requestCompactionV2Streaming(
+	model: Model,
+	apiKey: string,
+	request: CompactionV2Request,
+	signal?: AbortSignal,
+	options?: {
+		fetch?: FetchImpl;
+		timeoutMs?: number;
+		retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+	},
+): Promise<CompactionV2Response> {
+	const endpoint = getCompactionV2Endpoint(model);
+	if (!endpoint) {
+		throw new Error(`Model ${model.id} does not support V2 streaming compaction`);
+	}
+
+	const fetchImpl = options?.fetch ?? globalThis.fetch;
+	const retryWait = options?.retryWait ?? ((delayMs: number) => Bun.sleep(delayMs));
+	let lastError: Error | undefined;
+
+	for (let attempt = 0; attempt <= V2_COMPACTION_MAX_RETRIES; attempt++) {
+		const timeoutSignal = withRequestTimeout(signal, options?.timeoutMs ?? V2_COMPACTION_TIMEOUT_MS);
+		try {
+			return await attemptCompactionV2Streaming(endpoint, apiKey, model, request, fetchImpl, timeoutSignal);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			if (signal?.aborted) throw error;
+
+			if (isRetryableCompactionError(error) && attempt < V2_COMPACTION_MAX_RETRIES) {
+				lastError = error;
+				const backoffMs = 2 ** attempt * 1000;
+				logger.warn(`V2 compaction attempt ${attempt + 1} failed, retrying in ${backoffMs}ms`, {
+					error: error.message,
+					model: model.id,
+				});
+				await retryWait(backoffMs, signal);
+				if (signal?.aborted) throw error;
+				continue;
+			}
+
+			throw error;
+		}
+	}
+
+	throw lastError ?? new Error("V2 compaction failed after max retries");
+}
+
+async function attemptCompactionV2Streaming(
+	endpoint: string,
+	apiKey: string,
+	model: Model,
+	request: CompactionV2Request,
+	fetchImpl: FetchImpl,
+	signal?: AbortSignal,
+): Promise<CompactionV2Response> {
+	// Faithful to Codex: append the compaction trigger as the final input item
+	// of an otherwise-normal Responses request, then stream the result. `store`
+	// stays false — compaction must never persist a server-side response object.
+	const cacheOptions = { sessionId: request.sessionId, promptCacheKey: request.promptCacheKey };
+	const promptCacheKey = getOpenAIResponsesPromptCacheKey(cacheOptions);
+	const body: Record<string, unknown> = {
+		model: request.model,
+		input: [...request.input, COMPACTION_TRIGGER_ITEM],
+		instructions: request.instructions,
+		stream: true,
+		store: false,
+		...(request.reasoning ? { reasoning: request.reasoning, include: ["reasoning.encrypted_content"] } : {}),
+		...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
+		...(request.tools && request.tools.length > 0 ? { tools: request.tools, tool_choice: "auto" } : {}),
+	};
+	const response = await fetchImpl(endpoint, {
+		method: "POST",
+		headers: buildCompactionV2Headers(model, apiKey, request),
+		body: JSON.stringify(body),
+		signal,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text().catch(() => "");
+		logger.warn("V2 remote compaction failed", {
+			endpoint,
+			status: response.status,
+			statusText: response.statusText,
+			errorText,
+		});
+		throw new ProviderHttpError(
+			`V2 remote compaction failed (${response.status} ${response.statusText})`,
+			response.status,
+			{
+				headers: response.headers,
+			},
+		);
+	}
+
+	return collectCompactionV2Output(response, request);
+}
+
+function buildCompactionV2Headers(model: Model, apiKey: string, request: CompactionV2Request): Record<string, string> {
+	const api = compactionV2Api(model);
+	const cacheOptions = { sessionId: request.sessionId, promptCacheKey: request.promptCacheKey };
+	const routingSessionId = getOpenAIResponsesRoutingSessionId(cacheOptions);
+	const promptCacheSessionId = getOpenAIResponsesPromptCacheKey(cacheOptions);
+	const headers: Record<string, string> =
+		api === "azure-openai-responses"
+			? {
+					"content-type": "application/json",
+					"api-key": apiKey,
+					...(model.headers ?? {}),
+				}
+			: {
+					"content-type": "application/json",
+					...resolveOpenAIRequestSetup(
+						{ provider: model.provider, id: model.id, baseUrl: model.baseUrl, headers: model.headers },
+						{ apiKey, messages: [], openAISessionId: routingSessionId, promptCacheSessionId },
+					).headers,
+				};
+	if (api === "openai-codex-responses" || model.provider === "openai-codex") {
+		const accountId = getCodexAccountId(apiKey);
+		if (accountId) {
+			headers[OPENAI_HEADERS.ACCOUNT_ID] = accountId;
+		}
+		if (routingSessionId) {
+			headers[OPENAI_HEADERS.CONVERSATION_ID] = routingSessionId;
+			headers[OPENAI_HEADERS.SESSION_ID] = routingSessionId;
+			headers["x-client-request-id"] = routingSessionId;
+		}
+		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
+		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
+	}
+
+	return headers;
+}
+
+async function collectCompactionV2Output(
+	response: Response,
+	request: CompactionV2Request,
+): Promise<CompactionV2Response> {
+	const reader = response.body?.getReader();
+	if (!reader) {
+		throw new Error("No response body for V2 compaction streaming");
+	}
+
+	const state = {
+		outputItemCount: 0,
+		compactionItems: [] as Array<Record<string, unknown>>,
+		sawCompleted: false,
+		usage: undefined as CompactionV2Usage | undefined,
+	};
+
+	try {
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let eventName: string | undefined;
+		let dataLines: string[] = [];
+
+		const dispatch = (): void => {
+			if (dataLines.length === 0) {
+				eventName = undefined;
+				return;
+			}
+			handleCompactionV2SseEvent(dataLines.join("\n"), eventName, state);
+			eventName = undefined;
+			dataLines = [];
+		};
+
+		while (true) {
+			const { done, value } = await reader.read();
+			buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+			let lineEnd = buffer.indexOf("\n");
+			while (lineEnd >= 0) {
+				const rawLine = buffer.slice(0, lineEnd).replace(/\r$/, "");
+				buffer = buffer.slice(lineEnd + 1);
+				if (rawLine === "") {
+					dispatch();
+				} else if (rawLine.startsWith("event:")) {
+					eventName = rawLine.slice("event:".length).trim();
+				} else if (rawLine.startsWith("data:")) {
+					dataLines.push(rawLine.slice("data:".length).trimStart());
+				}
+				lineEnd = buffer.indexOf("\n");
+			}
+			if (done) break;
+		}
+		if (buffer.length > 0) {
+			if (buffer.startsWith("data:")) {
+				dataLines.push(buffer.slice("data:".length).trimStart());
+			} else if (buffer.startsWith("event:")) {
+				eventName = buffer.slice("event:".length).trim();
+			}
+		}
+		dispatch();
+	} finally {
+		reader.releaseLock();
+	}
+
+	if (!state.sawCompleted) {
+		throw new Error("V2 compaction stream closed before response.completed");
+	}
+	if (state.compactionItems.length !== 1) {
+		throw new Error(
+			`V2 compaction expected exactly one compaction output item, got ${state.compactionItems.length} from ${state.outputItemCount} output items`,
+		);
+	}
+
+	const compactionItem = state.compactionItems[0];
+	const { replacementHistory, retainedImageCount } = buildCompactionV2ReplacementHistory(
+		request.input,
+		compactionItem,
+		request.retainedMessageBudget,
+	);
+
+	return {
+		compactionItem,
+		replacementHistory,
+		usedTokens: state.usage?.inputTokens ?? 0,
+		usage: state.usage,
+		retainedImageCount,
+	};
+}
+
+function handleCompactionV2SseEvent(
+	data: string,
+	eventName: string | undefined,
+	state: {
+		outputItemCount: number;
+		compactionItems: Array<Record<string, unknown>>;
+		sawCompleted: boolean;
+		usage: CompactionV2Usage | undefined;
+	},
+): void {
+	if (data === "[DONE]") return;
+	let event: Record<string, unknown>;
+	try {
+		event = JSON.parse(data) as Record<string, unknown>;
+	} catch (err) {
+		throw new Error(`V2 compaction stream parse failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+
+	const type = typeof event.type === "string" ? event.type : eventName;
+	if (type === "response.output_item.done") {
+		state.outputItemCount++;
+		const item = event.item;
+		if (isRecord(item) && item.type === "compaction") {
+			state.compactionItems.push(item);
+		}
+		return;
+	}
+
+	if (type === "response.completed" || type === "response.done") {
+		state.sawCompleted = true;
+		state.usage = parseCompactionV2Usage(event);
+		return;
+	}
+
+	if (type === "response.failed" || type === "response.incomplete") {
+		throw new Error(formatCompactionV2Failure(event, type));
+	}
+}
+
+function parseCompactionV2Usage(event: Record<string, unknown>): CompactionV2Usage | undefined {
+	const response = isRecord(event.response) ? event.response : undefined;
+	const usage = response && isRecord(response.usage) ? response.usage : undefined;
+	if (!usage) return undefined;
+
+	const inputTokens = numberField(usage, "input_tokens");
+	const outputTokens = numberField(usage, "output_tokens");
+	const totalTokens = numberField(usage, "total_tokens");
+	if (inputTokens === undefined || outputTokens === undefined || totalTokens === undefined) return undefined;
+
+	const inputDetails = isRecord(usage.input_tokens_details) ? usage.input_tokens_details : undefined;
+	const outputDetails = isRecord(usage.output_tokens_details) ? usage.output_tokens_details : undefined;
+	const cachedInputTokens = inputDetails ? numberField(inputDetails, "cached_tokens") : undefined;
+	const reasoningOutputTokens = outputDetails ? numberField(outputDetails, "reasoning_tokens") : undefined;
+	return {
+		inputTokens,
+		outputTokens,
+		totalTokens,
+		...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+		...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+	};
+}
+
+function formatCompactionV2Failure(event: Record<string, unknown>, type: string): string {
+	const response = isRecord(event.response) ? event.response : undefined;
+	const error = isRecord(event.error)
+		? event.error
+		: response && isRecord(response.error)
+			? response.error
+			: undefined;
+	const message = error ? stringField(error, "message") : undefined;
+	const code = error ? (stringField(error, "code") ?? stringField(error, "type")) : undefined;
+	return `V2 compaction stream ${type}${code ? ` (${code})` : ""}${message ? `: ${message}` : ""}`;
+}
+
+function isRetryableCompactionError(error: Error): boolean {
+	if (
+		error.name === "AbortError" ||
+		error.name === "TimeoutError" ||
+		error.message.toLowerCase().includes("timeout")
+	) {
+		return true;
+	}
+	if (error instanceof ProviderHttpError) {
+		return isTransientStatus(error.status);
+	}
+	const message = error.message.toLowerCase();
+	return (
+		message.includes("stream closed before response.completed") ||
+		message.includes("stream parse failed") ||
+		message.includes("server_error") ||
+		message.includes("internal_error") ||
+		message.includes("overloaded") ||
+		message.includes("service unavailable")
+	);
+}
+
+// ============================================================================
+// Replacement History
+// ============================================================================
+
+/** Build Codex-style V2 replacement history from prompt input plus compaction output. */
+export function buildCompactionV2ReplacementHistory(
+	input: unknown[],
+	compactionItem: Record<string, unknown>,
+	retainedMessageBudget = V2_RETAINED_MESSAGE_TOKEN_BUDGET,
+): { replacementHistory: Array<Record<string, unknown>>; retainedImageCount: number } {
+	const retained = input.filter(
+		(item): item is Record<string, unknown> =>
+			isRecord(item) && isRetainedForCompactionV2(item) && shouldKeepCompactionV2HistoryItem(item),
+	);
+	const replacementHistory = truncateRetainedMessagesForCompactionV2(
+		retained,
+		resolveCompactionV2RetainedMessageBudget(retainedMessageBudget),
+	);
+	const retainedImageCount = replacementHistory.reduce((count, item) => count + retainedInputImageCount(item), 0);
+	replacementHistory.push(compactionItem);
+	return { replacementHistory, retainedImageCount };
+}
+
+function isRetainedForCompactionV2(item: Record<string, unknown>): boolean {
+	if (item.type !== "message") return false;
+	const role = stringField(item, "role");
+	return role === "user" || role === "developer" || role === "system";
+}
+
+function shouldKeepCompactionV2HistoryItem(item: Record<string, unknown>): boolean {
+	if (item.type !== "message") return item.type === "compaction";
+	const role = stringField(item, "role");
+	if (role !== "user") return false;
+	return !isContextualUserMessage(item);
+}
+
+function isContextualUserMessage(item: Record<string, unknown>): boolean {
+	const content = Array.isArray(item.content) ? item.content : [];
+	return content.some(part => {
+		if (!isRecord(part) || part.type !== "input_text") return false;
+		const text = stringField(part, "text")?.trimStart().toLowerCase();
+		return !!text && CONTEXTUAL_USER_PREFIXES.some(prefix => text.startsWith(prefix));
+	});
+}
+
+function retainedInputImageCount(item: Record<string, unknown>): number {
+	const content = Array.isArray(item.content) ? item.content : [];
+	let count = 0;
+	for (const part of content) {
+		if (isRecord(part) && part.type === "input_image") count++;
+	}
+	return count;
+}
+
+function truncateRetainedMessagesForCompactionV2(
+	items: Array<Record<string, unknown>>,
+	maxTokens: number,
+): Array<Record<string, unknown>> {
+	let remaining = maxTokens;
+	const truncatedReversed: Array<Record<string, unknown>> = [];
+	for (let i = items.length - 1; i >= 0; i--) {
+		if (remaining === 0) continue;
+		const item = items[i];
+		const tokenCount = Math.max(messageContentTokenCount(item), 1);
+		if (tokenCount <= remaining) {
+			truncatedReversed.push(item);
+			remaining = Math.max(0, remaining - tokenCount);
+			continue;
+		}
+
+		const truncatedItem = truncateMessageTextToTokenBudget(item, remaining);
+		if (truncatedItem) {
+			truncatedReversed.push(truncatedItem);
+			remaining = 0;
+		}
+	}
+	truncatedReversed.reverse();
+	return truncatedReversed;
+}
+
+function messageContentTokenCount(item: Record<string, unknown>): number {
+	const content = Array.isArray(item.content) ? item.content : [];
+	let tokens = 0;
+	for (const part of content) {
+		if (!isRecord(part)) continue;
+		if (part.type === "input_image") {
+			tokens += IMAGE_TOKEN_ESTIMATE;
+			continue;
+		}
+		if (part.type === "input_text" || part.type === "output_text") {
+			tokens += approxTokenCount(stringField(part, "text") ?? "");
+		}
+	}
+	return tokens;
+}
+
+function truncateMessageTextToTokenBudget(
+	item: Record<string, unknown>,
+	maxTokens: number,
+): Record<string, unknown> | undefined {
+	const content = Array.isArray(item.content) ? item.content : [];
+	let remaining = maxTokens;
+	const truncatedContent: unknown[] = [];
+	for (const part of content) {
+		if (!isRecord(part)) continue;
+		if (part.type === "input_image") {
+			if (remaining < IMAGE_TOKEN_ESTIMATE) continue;
+			truncatedContent.push(part);
+			remaining = Math.max(0, remaining - IMAGE_TOKEN_ESTIMATE);
+			continue;
+		}
+		if (part.type !== "input_text" && part.type !== "output_text") continue;
+		if (remaining === 0) continue;
+
+		const text = stringField(part, "text") ?? "";
+		const tokenCount = approxTokenCount(text);
+		if (tokenCount <= remaining) {
+			truncatedContent.push(part);
+			remaining = Math.max(0, remaining - tokenCount);
+			continue;
+		}
+
+		const truncatedText = truncateTextToTokenBudget(text, remaining);
+		remaining = 0;
+		if (truncatedText.length > 0) {
+			truncatedContent.push({ ...part, text: truncatedText });
+		}
+	}
+
+	if (truncatedContent.length === 0) return undefined;
+	return { ...item, content: truncatedContent };
+}
+
+function truncateTextToTokenBudget(text: string, maxTokens: number): string {
+	if (maxTokens <= 0) return "";
+	const maxChars = maxTokens * 4;
+	if (text.length <= maxChars) return text;
+	const omittedTokens = Math.max(1, approxTokenCount(text) - maxTokens);
+	const marker = `…${omittedTokens} tokens truncated…`;
+	if (maxChars <= marker.length + 2) return text.slice(0, maxChars);
+	const sideChars = Math.max(1, Math.floor((maxChars - marker.length) / 2));
+	return `${text.slice(0, sideChars)}${marker}${text.slice(-sideChars)}`;
+}
+
+function approxTokenCount(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+// ============================================================================
+// Preserve Data
+// ============================================================================
+
+/** Store V2 replacement history in the OpenAI remote-compaction preserve slot. */
+export function storeCompactionV2PreserveData(response: CompactionV2Response, model: Model): Record<string, unknown> {
+	return {
+		[OPENAI_REMOTE_COMPACTION_PRESERVE_KEY]: {
+			version: "v2",
+			provider: model.provider,
+			replacementHistory: response.replacementHistory,
+			usedTokens: response.usedTokens,
+			usage: response.usage,
+			retainedImageCount: response.retainedImageCount,
+		},
+	};
+}
+
+/** Retrieve preserved OpenAI replacement history that V2 can extend. */
+export function getCompactionV2PreserveData(
+	preserveData: Record<string, unknown> | undefined,
+): { provider: string; replacementHistory: Array<Record<string, unknown>>; usedTokens: number } | undefined {
+	const candidate = preserveData?.[OPENAI_REMOTE_COMPACTION_PRESERVE_KEY];
+	if (!isRecord(candidate)) return undefined;
+	const provider = stringField(candidate, "provider");
+	if (!provider) return undefined;
+	if (!Array.isArray(candidate.replacementHistory)) return undefined;
+
+	return {
+		provider,
+		replacementHistory: candidate.replacementHistory as Array<Record<string, unknown>>,
+		usedTokens: numberField(candidate, "usedTokens") ?? 0,
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object";
+}
+
+function stringField(record: Record<string, unknown>, field: string): string | undefined {
+	const value = record[field];
+	return typeof value === "string" ? value : undefined;
+}
+
+function numberField(record: Record<string, unknown>, field: string): number | undefined {
+	const value = record[field];
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/src/compaction/compaction.ts

@@ -20,6 +20,8 @@ import {
 	withAuth,
 } from "@oh-my-pi/pi-ai";
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
+import { convertTools } from "@oh-my-pi/pi-ai/providers/openai-responses";
+import { buildResponsesInput, resolveOpenAICompatPolicy } from "@oh-my-pi/pi-ai/providers/openai-shared";
 import { preferredDialect } from "@oh-my-pi/pi-catalog/identity";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
@@ -28,6 +30,14 @@ import { type AgentTelemetry, instrumentedCompleteSimple } from "../telemetry";
 import { ThinkingLevel } from "../thinking";
 import { countTokens } from "../tokenizer";
 import type { AgentMessage } from "../types";
+import {
+	buildCompactionV2Request,
+	getCompactionV2PreserveData,
+	requestCompactionV2Streaming,
+	shouldUseCompactionV2Streaming,
+	storeCompactionV2PreserveData,
+	V2_RETAINED_MESSAGE_TOKEN_BUDGET,
+} from "./compaction-v2-streaming";
 import type { CompactionEntry, SessionEntry } from "./entries";
 import { type ConvertToLlm, createBranchSummaryMessage, createCustomMessage, defaultConvertToLlm } from "./messages";
 import {
@@ -155,6 +165,8 @@ export interface CompactionSettings {
 	autoContinue?: boolean;
 	remoteEnabled?: boolean;
 	remoteEndpoint?: string;
+	remoteStreamingV2Enabled?: boolean;
+	v2RetainedMessageBudget?: number;
 }
 
 export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
@@ -167,6 +179,8 @@ export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	keepRecentTokens: 20000,
 	autoContinue: true,
 	remoteEnabled: true,
+	remoteStreamingV2Enabled: true,
+	v2RetainedMessageBudget: V2_RETAINED_MESSAGE_TOKEN_BUDGET,
 };
 
 // ============================================================================
@@ -657,6 +671,12 @@ export interface SummaryOptions {
 	 * `resolveCompactionEffort` for the conversion contract.
 	 */
 	thinkingLevel?: ThinkingLevel;
+	/** Session routing key for remote compaction transports with sticky provider sessions. */
+	sessionId?: string;
+	/** Prompt-cache key for remote compaction transports that support provider prefix caching. */
+	promptCacheKey?: string;
+	/** Provider-visible tools for remote compaction transports that replay native tool history. */
+	tools?: Tool[];
 	/** Optional fetch implementation threaded into remote compaction calls. */
 	fetch?: FetchImpl;
 }
@@ -972,9 +992,34 @@ export interface CompactionPreparation {
 	settings: CompactionSettings;
 }
 
+/**
+ * Whether a prior compaction's preserve data can be carried forward by the
+ * upcoming compaction. A local compaction (no remote preserve) always can — it
+ * holds a real textual summary. A remote compaction (V2 or V1) only can when
+ * some candidate model shares its provider AND remote replay is still enabled;
+ * otherwise its provider-native replay is dead weight and only the opaque
+ * placeholder summary survives, so the caller must re-expand the originals.
+ */
+function remotePreserveReusableByAny(
+	preserveData: Record<string, unknown> | undefined,
+	models: readonly Model[],
+	settings: CompactionSettings,
+): boolean {
+	const remote = getCompactionV2PreserveData(preserveData) ?? getPreservedOpenAiRemoteCompactionData(preserveData);
+	if (!remote) return true;
+	if (settings.remoteEnabled === false) return false;
+	for (const model of models) {
+		if (remote.provider !== model.provider) continue;
+		const v2Ok = settings.remoteStreamingV2Enabled !== false && shouldUseCompactionV2Streaming(model);
+		if (v2Ok || shouldUseOpenAiRemoteCompaction(model)) return true;
+	}
+	return false;
+}
+
 export function prepareCompaction(
 	pathEntries: SessionEntry[],
 	settings: CompactionSettings,
+	compactionModels: readonly Model[] = [],
 ): CompactionPreparation | undefined {
 	if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
 		return undefined;
@@ -982,10 +1027,18 @@ export function prepareCompaction(
 
 	let prevCompactionIndex = -1;
 	for (let i = pathEntries.length - 1; i >= 0; i--) {
-		if (pathEntries[i].type === "compaction") {
-			prevCompactionIndex = i;
-			break;
+		if (pathEntries[i].type !== "compaction") continue;
+		// Skip a prior remote compaction (V2 or V1) whose provider-native replay
+		// none of the upcoming compaction candidates can reuse: its summary is only
+		// an opaque placeholder, so re-expand its original messages and summarize
+		// them locally rather than stranding that history. compact() still reuses it
+		// when a candidate can (same provider, remote enabled).
+		const entry = pathEntries[i] as CompactionEntry;
+		if (compactionModels.length > 0 && !remotePreserveReusableByAny(entry.preserveData, compactionModels, settings)) {
+			continue;
 		}
+		prevCompactionIndex = i;
+		break;
 	}
 	const boundaryStart = prevCompactionIndex + 1;
 	const boundaryEnd = pathEntries.length;
@@ -1079,6 +1132,49 @@ export function prepareCompaction(
 
 const TURN_PREFIX_SUMMARIZATION_PROMPT = prompt.render(compactionTurnPrefixPrompt);
 
+function openAiCompatSupportsImageDetailOriginal(model: Model): boolean {
+	const compat = model.compat;
+	return !!compat && "supportsImageDetailOriginal" in compat && compat.supportsImageDetailOriginal === true;
+}
+
+function buildOpenAiResponsesCompactionInput(
+	messages: Message[],
+	model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">,
+	previousReplacementHistory: Array<Record<string, unknown>> | undefined,
+): unknown[] {
+	const input = buildResponsesInput({
+		model,
+		context: { messages },
+		strictResponsesPairing: model.compat.strictResponsesPairing,
+		supportsImageDetailOriginal: openAiCompatSupportsImageDetailOriginal(model),
+		nativeHistory: { replay: true, filterReasoning: false },
+		includeThinkingSignatures: true,
+		repairOrphanOutputs: true,
+	});
+	return previousReplacementHistory ? [...previousReplacementHistory, ...input] : input;
+}
+
+/**
+ * Resolve the Responses `reasoning` param for a V2 compaction request the same
+ * way a normal turn does — through {@link resolveOpenAICompatPolicy}, so it
+ * honors per-model effort support, `omitReasoningEffort`, disable modes, and the
+ * wire-effort mapping. Returns `undefined` for non-reasoning models or when the
+ * user selected `Off` (matching the normal-turn omission, not a fabricated shape).
+ */
+function buildCompactionV2Reasoning(
+	model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">,
+	thinkingLevel: ThinkingLevel | undefined,
+): { effort: string; summary: string } | undefined {
+	const policy = resolveOpenAICompatPolicy(model, {
+		endpoint: "responses",
+		reasoning: resolveCompactionEffort(model, thinkingLevel),
+	});
+	const reasoning = policy.reasoning;
+	if (!reasoning.modelSupported || reasoning.disabled || reasoning.omitReasoningEffort) return undefined;
+	if (reasoning.requestedEffort === undefined) return undefined;
+	return { effort: reasoning.wireEffort ?? reasoning.requestedEffort, summary: "auto" };
+}
+
 /**
  * Generate summaries for compaction using prepared data.
  * Returns CompactionResult - SessionManager adds id/parentId when saving.
@@ -1122,6 +1218,9 @@ export async function compact(
 		// silently falls back to Effort.High — the same defect e07b47ee4 fixed
 		// at the call sites, leaked back in here. See resolveCompactionEffort.
 		thinkingLevel: options?.thinkingLevel,
+		sessionId: options?.sessionId,
+		promptCacheKey: options?.promptCacheKey,
+		tools: options?.tools,
 		fetch: options?.fetch,
 	};
 
@@ -1138,18 +1237,74 @@ export async function compact(
 		: undefined;
 
 	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
-	if (settings.remoteEnabled !== false && shouldUseOpenAiRemoteCompaction(model)) {
-		const previousRemoteCompaction = getPreservedOpenAiRemoteCompactionData(previousPreserveData);
-		const remoteMessages: AgentMessage[] = [
-			...(snapcompactArchiveMigrationMessage ? [snapcompactArchiveMigrationMessage] : []),
-			...messagesToSummarize,
-			...turnPrefixMessages,
-			...recentMessages,
-		];
+	const remoteMessages: AgentMessage[] = [
+		...(snapcompactArchiveMigrationMessage ? [snapcompactArchiveMigrationMessage] : []),
+		...messagesToSummarize,
+		...turnPrefixMessages,
+		...recentMessages,
+	];
+	let usedRemoteCompaction = false;
+	if (
+		settings.remoteEnabled !== false &&
+		settings.remoteStreamingV2Enabled !== false &&
+		shouldUseCompactionV2Streaming(model)
+	) {
+		const previousRemoteCompaction = getCompactionV2PreserveData(previousPreserveData);
 		const previousReplacementHistory =
 			previousRemoteCompaction?.provider === model.provider
 				? previousRemoteCompaction.replacementHistory
 				: undefined;
+		const remoteHistory = buildOpenAiResponsesCompactionInput(
+			(summaryOptions.convertToLlm ?? defaultConvertToLlm)(remoteMessages),
+			model,
+			previousReplacementHistory,
+		);
+		if (remoteHistory.length > 0) {
+			try {
+				const request = buildCompactionV2Request(
+					model,
+					remoteHistory,
+					summaryOptions.remoteInstructions ?? SUMMARIZATION_SYSTEM_PROMPT,
+					{
+						tools: summaryOptions.tools
+							? convertTools(summaryOptions.tools, model.compat.supportsStrictMode, model)
+							: undefined,
+						reasoning: buildCompactionV2Reasoning(model, summaryOptions.thinkingLevel),
+						sessionId: summaryOptions.sessionId,
+						promptCacheKey: summaryOptions.promptCacheKey,
+						retainedMessageBudget: settings.v2RetainedMessageBudget,
+					},
+				);
+				const remote = await withAuth(
+					apiKey,
+					key => requestCompactionV2Streaming(model, key, request, signal, { fetch: summaryOptions.fetch }),
+					{ signal },
+				);
+				preserveData = { ...(preserveData ?? {}), ...storeCompactionV2PreserveData(remote, model) };
+				usedRemoteCompaction = true;
+			} catch (err) {
+				// A user/session abort is a cancellation, not a remote failure —
+				// swallowing it here would downgrade Esc into "fall back to local
+				// summarization" and keep compaction running on an aborted signal.
+				if (signal?.aborted) throw err;
+				logger.warn("OpenAI V2 remote compaction failed, falling back to V1/local summarization", {
+					error: err instanceof Error ? err.message : String(err),
+					model: model.id,
+					provider: model.provider,
+				});
+			}
+		}
+	}
+
+	if (!usedRemoteCompaction && settings.remoteEnabled !== false && shouldUseOpenAiRemoteCompaction(model)) {
+		const previousRemoteCompaction = getPreservedOpenAiRemoteCompactionData(previousPreserveData);
+		const previousV2Compaction = getCompactionV2PreserveData(previousPreserveData);
+		const previousReplacementHistory =
+			previousRemoteCompaction?.provider === model.provider
+				? previousRemoteCompaction.replacementHistory
+				: previousV2Compaction?.provider === model.provider
+					? previousV2Compaction.replacementHistory
+					: undefined;
 		const remoteHistory = buildOpenAiNativeHistory(
 			(summaryOptions.convertToLlm ?? defaultConvertToLlm)(remoteMessages),
 			model,
@@ -1171,6 +1326,7 @@ export async function compact(
 					{ signal },
 				);
 				preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, remote);
+				usedRemoteCompaction = true;
 			} catch (err) {
 				// A user/session abort is a cancellation, not a remote failure —
 				// swallowing it here would downgrade Esc into "fall back to local
@@ -1188,7 +1344,18 @@ export async function compact(
 	// Generate summaries (can be parallel if both needed) and merge into one
 	let summary: string;
 
-	if (isSplitTurn && turnPrefixMessages.length > 0) {
+	if (usedRemoteCompaction) {
+		// Remote compaction (V2 or V1) already compacted remotely; the durable
+		// history lives in the provider replay payload (preserveData). Skip local
+		// summarization so a successful remote compaction never pays for a second,
+		// redundant LLM round. If a LATER compaction cannot reuse this payload,
+		// prepareCompaction re-expands the original messages and summarizes them
+		// locally then (see remotePreserveReusableByAny).
+		const usedTokens = getCompactionV2PreserveData(preserveData)?.usedTokens ?? 0;
+		summary =
+			"Remote compaction preserved provider-native history for this session." +
+			(usedTokens > 0 ? ` Retained ${usedTokens} tokens in the provider replay payload.` : "");
+	} else if (isSplitTurn && turnPrefixMessages.length > 0) {
 		// Generate both summaries in parallel
 		const [historyResult, turnPrefixResult] = await Promise.all([
 			messagesToSummarize.length > 0 || previousSummaryForCompaction
@@ -1227,25 +1394,19 @@ export async function compact(
 		summary = "No prior history.";
 	}
 
-	const shortSummary = await generateShortSummary(
-		recentMessages,
-		summary,
-		model,
-		settings.reserveTokens,
-		apiKey,
-		signal,
-		{
-			extraContext: options?.extraContext,
-			remoteEndpoint: summaryOptions.remoteEndpoint,
-			initiatorOverride: summaryOptions.initiatorOverride,
-			metadata: summaryOptions.metadata,
-			telemetry: summaryOptions.telemetry,
-			// Same propagation as summaryOptions above — generateShortSummary
-			// resolves its own reasoning via resolveCompactionEffort.
-			thinkingLevel: options?.thinkingLevel,
-			fetch: summaryOptions.fetch,
-		},
-	);
+	const shortSummary = usedRemoteCompaction
+		? "Remote compaction"
+		: await generateShortSummary(recentMessages, summary, model, settings.reserveTokens, apiKey, signal, {
+				extraContext: options?.extraContext,
+				remoteEndpoint: summaryOptions.remoteEndpoint,
+				initiatorOverride: summaryOptions.initiatorOverride,
+				metadata: summaryOptions.metadata,
+				telemetry: summaryOptions.telemetry,
+				// Same propagation as summaryOptions above — generateShortSummary
+				// resolves its own reasoning via resolveCompactionEffort.
+				thinkingLevel: options?.thinkingLevel,
+				fetch: summaryOptions.fetch,
+			});
 
 	// Compute file lists and append to summary
 	const { readFiles, modifiedFiles } = computeFileLists(fileOps);

package/src/compaction/entries.ts

@@ -77,6 +77,14 @@ export interface LabelEntry extends SessionEntryBase {
 	label: string | undefined;
 }
 
+export interface TitleChangeEntry extends SessionEntryBase {
+	type: "title_change";
+	title: string;
+	previousTitle?: string;
+	source: "auto" | "user";
+	trigger?: string;
+}
+
 export interface TtsrInjectionEntry extends SessionEntryBase {
 	type: "ttsr_injection";
 	/** Names of rules that were injected */
@@ -121,6 +129,7 @@ export type SessionEntry =
 	| CustomEntry
 	| CustomMessageEntry
 	| LabelEntry
+	| TitleChangeEntry
 	| TtsrInjectionEntry
 	| MCPToolSelectionEntry
 	| SessionInitEntry

package/src/compaction/openai.ts

@@ -1,9 +1,12 @@
 /**
  * Remote compaction utilities.
  *
- * Provider-side conversation summarization endpoints. Two flavors:
+ * Provider-side conversation summarization endpoints. Three flavors:
  *
- * - **OpenAI remote compaction** (`/responses/compact`): preserves encrypted
+ * - **OpenAI remote compaction V2** (Responses streaming): appends a
+ *   `compaction_trigger` input item to the normal stream and stores the returned
+ *   `compaction` item with retained real user messages in `preserveData`.
+ * - **OpenAI remote compaction V1** (`/responses/compact`): preserves encrypted
  *   reasoning across compactions by submitting the full responses-API native
  *   history and storing the returned `compaction` / `compaction_summary`
  *   item in `preserveData` so future turns can replay the encrypted state.
@@ -29,6 +32,8 @@ import {
 } from "@oh-my-pi/pi-catalog/wire/codex";
 import { $env, logger } from "@oh-my-pi/pi-utils";
 
+export * from "./compaction-v2-streaming";
+
 // ============================================================================
 // Public types
 // ============================================================================
@@ -214,57 +219,12 @@ export function withOpenAiRemoteCompactionPreserveData(
 // Input/output filtering for OpenAI compact endpoint
 // ============================================================================
 
-function shouldTrimOpenAiCompactInputItem(item: Record<string, unknown>): boolean {
-	return item.type === "function_call_output" || (item.type === "message" && item.role === "developer");
-}
-
 function shouldKeepOpenAiCompactOutputItem(item: Record<string, unknown>): boolean {
 	if (item.type === "compaction" || item.type === "compaction_summary") return true;
 	if (item.type !== "message") return false;
 	return item.role === "assistant" || item.role === "user";
 }
 
-function trimOpenAiCompactInput(
-	input: Array<Record<string, unknown>>,
-	contextWindow: number,
-	instructions: string,
-): Array<Record<string, unknown>> {
-	const trimmed = [...input];
-	// Per-item serialized sizes are cached and decremented on removal.
-	// Re-stringifying the whole input per popped item was O(N²) in total chars
-	// — hundreds of MB of stringify churn on a 200k-token codex history,
-	// blocking the event loop for seconds (same class as the addOpenAiCallIds
-	// fix above).
-	const sizes = trimmed.map(item => JSON.stringify(item).length);
-	let chars = instructions.length;
-	for (const size of sizes) chars += size;
-	const removeAt = (index: number): void => {
-		chars -= sizes[index] ?? 0;
-		trimmed.splice(index, 1);
-		sizes.splice(index, 1);
-	};
-	while (trimmed.length > 0 && Math.ceil(chars / 4) > contextWindow) {
-		const last = trimmed[trimmed.length - 1];
-		if (last?.type === "function_call_output" || last?.type === "custom_tool_call_output") {
-			const callId = typeof last.call_id === "string" ? last.call_id : undefined;
-			const callType = last.type === "custom_tool_call_output" ? "custom_tool_call" : "function_call";
-			removeAt(trimmed.length - 1);
-			if (callId) {
-				const matchingCallIndex = trimmed.findLastIndex(item => item.type === callType && item.call_id === callId);
-				if (matchingCallIndex >= 0) {
-					removeAt(matchingCallIndex);
-				}
-			}
-			continue;
-		}
-		if (!last || !shouldTrimOpenAiCompactInputItem(last)) {
-			break;
-		}
-		removeAt(trimmed.length - 1);
-	}
-	return trimmed;
-}
-
 // Register every tool-call id in `items` (and the subset using the custom-tool
 // wire shape) into the running sets. The history builder maintains both sets
 // incrementally as native history is appended, so this only scans the
@@ -506,7 +466,10 @@ export async function requestOpenAiRemoteCompaction(
 	const requestModel = resolveOpenAiCompactModel(model);
 	const request: OpenAiRemoteCompactionRequest = {
 		model: requestModel,
-		input: trimOpenAiCompactInput(compactInput, model.contextWindow ?? Number.POSITIVE_INFINITY, instructions),
+		// Send full history to the endpoint - don't trim locally.
+		// The provider handles compression via the compaction endpoint.
+		// Trimming before sending loses assistant messages and thinking blocks.
+		input: compactInput,
 		instructions,
 	};
 	const isAzureOpenAiResponses = (model.remoteCompaction?.api ?? model.api) === "azure-openai-responses";