@oh-my-pi/pi-coding-agent 13.9.2 → 13.9.4

package/src/session/agent-storage.ts

@@ -276,22 +276,20 @@ CREATE TABLE settings (
 	 * @returns Array of stored credentials with their database IDs
 	 */
 	listAuthCredentials(provider?: string, includeDisabled = false): StoredAuthCredential[] {
-		// AuthCredentialStore doesn't expose includeDisabled yet, so we filter if needed
 		const credentials = this.#authStore.listAuthCredentials(provider);
 		if (!includeDisabled) return credentials;
 
-		// For now, includeDisabled requires direct DB access
-		// This is only used internally, so it's acceptable
 		const stmt = this.#db.prepare(
 			provider
-				? "SELECT id, provider, credential_type, data FROM auth_credentials WHERE provider = ? ORDER BY id ASC"
-				: "SELECT id, provider, credential_type, data FROM auth_credentials ORDER BY id ASC",
+				? "SELECT id, provider, credential_type, data, disabled_cause FROM auth_credentials WHERE provider = ? ORDER BY id ASC"
+				: "SELECT id, provider, credential_type, data, disabled_cause FROM auth_credentials ORDER BY id ASC",
 		);
 		const rows = (provider ? stmt.all(provider) : stmt.all()) as Array<{
 			id: number;
 			provider: string;
 			credential_type: string;
 			data: string;
+			disabled_cause: string | null;
 		}>;
 
 		const results: StoredAuthCredential[] = [];
@@ -309,7 +307,7 @@ CREATE TABLE settings (
 					continue;
 				}
 
-				results.push({ id: row.id, provider: row.provider, credential });
+				results.push({ id: row.id, provider: row.provider, credential, disabledCause: row.disabled_cause });
 			} catch {}
 		}
 		return results;
@@ -336,19 +334,21 @@ CREATE TABLE settings (
 	}
 
 	/**
-	 * Deletes an auth credential by ID.
-	 * @param id - Database row ID of the credential to delete
+	 * Disables an auth credential by ID with a persisted cause.
+	 * @param id - Database row ID of the credential to disable
+	 * @param disabledCause - Human-readable cause stored with the disabled row
 	 */
-	deleteAuthCredential(id: number): void {
-		this.#authStore.deleteAuthCredential(id);
+	deleteAuthCredential(id: number, disabledCause: string): void {
+		this.#authStore.deleteAuthCredential(id, disabledCause);
 	}
 
 	/**
-	 * Deletes all auth credentials for a provider.
-	 * @param provider - Provider name whose credentials should be deleted
+	 * Disables all auth credentials for a provider with a persisted cause.
+	 * @param provider - Provider name whose credentials should be disabled
+	 * @param disabledCause - Human-readable cause stored with the disabled rows
 	 */
-	deleteAuthCredentialsForProvider(provider: string): void {
-		this.#authStore.deleteAuthCredentialsForProvider(provider);
+	deleteAuthCredentialsForProvider(provider: string, disabledCause: string): void {
+		this.#authStore.deleteAuthCredentialsForProvider(provider, disabledCause);
 	}
 
 	/**

package/src/session/compaction/compaction.ts

@@ -5,8 +5,15 @@
  * and after compaction the session is reloaded.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, Model, Usage } from "@oh-my-pi/pi-ai";
-import { completeSimple } from "@oh-my-pi/pi-ai";
+import { type AssistantMessage, completeSimple, Effort, type Model, type Usage } from "@oh-my-pi/pi-ai";
+import {
+	CODEX_BASE_URL,
+	getCodexAccountId,
+	OPENAI_HEADER_VALUES,
+	OPENAI_HEADERS,
+} from "@oh-my-pi/pi-ai/providers/openai-codex/constants";
+import { transformMessages } from "@oh-my-pi/pi-ai/providers/transform-messages";
+import { normalizeResponsesToolCallId } from "@oh-my-pi/pi-ai/utils";
 import { logger } from "@oh-my-pi/pi-utils";
 import { renderPromptTemplate } from "../../config/prompt-templates";
 import compactionShortSummaryPrompt from "../../prompts/compaction/compaction-short-summary.md" with { type: "text" };
@@ -115,17 +122,23 @@ export interface CompactionResult<T = unknown> {
 
 export interface CompactionSettings {
 	enabled: boolean;
+	strategy?: "context-full" | "handoff" | "off";
+	thresholdPercent?: number;
 	reserveTokens: number;
 	keepRecentTokens: number;
 	autoContinue?: boolean;
+	remoteEnabled?: boolean;
 	remoteEndpoint?: string;
 }
 
 export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	enabled: true,
+	strategy: "context-full",
+	thresholdPercent: -1,
 	reserveTokens: 16384,
 	keepRecentTokens: 20000,
 	autoContinue: true,
+	remoteEnabled: true,
 };
 
 // ============================================================================
@@ -187,8 +200,18 @@ export function effectiveReserveTokens(contextWindow: number, settings: Compacti
  * Check if compaction should trigger based on context usage.
  */
 export function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean {
-	if (!settings.enabled) return false;
-	return contextTokens > contextWindow - effectiveReserveTokens(contextWindow, settings);
+	if (!settings.enabled || settings.strategy === "off" || contextWindow <= 0) return false;
+	const thresholdTokens = resolveThresholdTokens(contextWindow, settings);
+	return contextTokens > thresholdTokens;
+}
+
+function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
+	const thresholdPercent = settings.thresholdPercent;
+	if (typeof thresholdPercent !== "number" || !Number.isFinite(thresholdPercent) || thresholdPercent <= 0) {
+		return contextWindow - effectiveReserveTokens(contextWindow, settings);
+	}
+	const clampedThresholdPercent = Math.min(99, Math.max(1, thresholdPercent));
+	return Math.floor(contextWindow * (clampedThresholdPercent / 100));
 }
 
 // ============================================================================
@@ -441,16 +464,439 @@ function formatAdditionalContext(context: string[] | undefined): string {
 	return `<additional-context>\n${lines}\n</additional-context>\n\n`;
 }
 
-interface RemoteCompactionRequest {
-	systemPrompt: string;
-	prompt: string;
+const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
+
+type OpenAiRemoteCompactionItem = {
+	type: "compaction" | "compaction_summary";
+	encrypted_content?: string;
+	summary?: string;
+};
+
+interface OpenAiRemoteCompactionPreserveData {
+	replacementHistory: Array<Record<string, unknown>>;
+	compactionItem: OpenAiRemoteCompactionItem;
 }
 
+interface OpenAiRemoteCompactionRequest {
+	model: string;
+	input: Array<Record<string, unknown>>;
+	instructions: string;
+}
+
+interface OpenAiRemoteCompactionResponse extends OpenAiRemoteCompactionPreserveData {}
+
 interface RemoteCompactionResponse {
 	summary: string;
 	shortSummary?: string;
 }
 
+function shouldUseOpenAiRemoteCompaction(model: Model): boolean {
+	return model.provider === "openai" || model.provider === "openai-codex";
+}
+
+function resolveOpenAiCompactEndpoint(model: Model): string {
+	if (model.provider === "openai-codex") {
+		return resolveOpenAiCodexCompactEndpoint(model.baseUrl);
+	}
+
+	const defaultBase = "https://api.openai.com/v1";
+	const rawBase = model.baseUrl && model.baseUrl.length > 0 ? model.baseUrl : defaultBase;
+	const normalizedBase = rawBase.endsWith("/") ? rawBase.slice(0, -1) : rawBase;
+	if (normalizedBase.endsWith("/v1")) return `${normalizedBase}/responses/compact`;
+	return `${normalizedBase}/v1/responses/compact`;
+}
+
+function resolveOpenAiCodexCompactEndpoint(baseUrl: string | undefined): string {
+	const rawBase = baseUrl && baseUrl.length > 0 ? baseUrl : CODEX_BASE_URL;
+	const normalizedBase = rawBase.endsWith("/") ? rawBase.slice(0, -1) : rawBase;
+	if (/\/codex(?:\/v\d+)?$/.test(normalizedBase)) return `${normalizedBase}/responses/compact`;
+	return `${normalizedBase}/codex/responses/compact`;
+}
+
+function normalizeOpenAiCompactionToolCallId(id: string): string {
+	const normalized = normalizeResponsesToolCallId(id);
+	return `${normalized.callId}|${normalized.itemId ?? normalized.callId}`;
+}
+
+function getPreservedOpenAiRemoteCompactionData(
+	preserveData: Record<string, unknown> | undefined,
+): OpenAiRemoteCompactionPreserveData | undefined {
+	const candidate = preserveData?.[OPENAI_REMOTE_COMPACTION_PRESERVE_KEY];
+	if (!candidate || typeof candidate !== "object") return undefined;
+	const maybeData = candidate as { replacementHistory?: unknown; compactionItem?: unknown };
+	if (!Array.isArray(maybeData.replacementHistory)) return undefined;
+	const maybeItem = maybeData.compactionItem;
+	if (!maybeItem || typeof maybeItem !== "object") return undefined;
+	const compactionItem = maybeItem as { type?: unknown; encrypted_content?: unknown; summary?: unknown };
+	const isClassicCompaction =
+		compactionItem.type === "compaction" && typeof compactionItem.encrypted_content === "string";
+	const isSummaryCompaction = compactionItem.type === "compaction_summary";
+	if (!isClassicCompaction && !isSummaryCompaction) {
+		return undefined;
+	}
+	return {
+		replacementHistory: maybeData.replacementHistory as Array<Record<string, unknown>>,
+		compactionItem: compactionItem as unknown as OpenAiRemoteCompactionItem,
+	};
+}
+
+function withOpenAiRemoteCompactionPreserveData(
+	preserveData: Record<string, unknown> | undefined,
+	remoteCompaction: OpenAiRemoteCompactionPreserveData | undefined,
+): Record<string, unknown> | undefined {
+	if (remoteCompaction) {
+		return {
+			...(preserveData ?? {}),
+			[OPENAI_REMOTE_COMPACTION_PRESERVE_KEY]: remoteCompaction,
+		};
+	}
+
+	if (!preserveData || !(OPENAI_REMOTE_COMPACTION_PRESERVE_KEY in preserveData)) {
+		return preserveData;
+	}
+
+	const { [OPENAI_REMOTE_COMPACTION_PRESERVE_KEY]: _removed, ...rest } = preserveData;
+	return Object.keys(rest).length > 0 ? rest : undefined;
+}
+
+function estimateOpenAiCompactInputTokens(input: Array<Record<string, unknown>>, instructions: string): number {
+	let chars = instructions.length;
+	for (const item of input) {
+		chars += JSON.stringify(item).length;
+	}
+	return Math.ceil(chars / 4);
+}
+
+function shouldTrimOpenAiCompactInputItem(item: Record<string, unknown>): boolean {
+	return item.type === "function_call_output" || (item.type === "message" && item.role === "developer");
+}
+
+function shouldKeepOpenAiCompactOutputUserMessage(item: Record<string, unknown>): boolean {
+	if (item.role !== "user") return false;
+	const content = item.content;
+	if (!Array.isArray(content) || content.length === 0) return false;
+	const contextualFragmentPatterns = [
+		[/^<system-reminder>[\s\S]*<\/system-reminder>$/i, /<system-reminder>/i],
+		[/^#\s*AGENTS\.md instructions for\b[\s\S]*<\/INSTRUCTIONS>$/i, /# AGENTS.md instructions/],
+		[/^<environment-context>[\s\S]*<\/environment-context>$/i, /<environment-context>/i],
+		[/^<skill>[\s\S]*<\/skill>$/i, /<skill>/i],
+		[/^<user-shell-command>[\s\S]*<\/user-shell-command>$/i, /<user-shell-command>/i],
+		[/^<turn-aborted>[\s\S]*<\/turn-aborted>$/i, /<turn-aborted>/i],
+		[/^<subagent-notification>[\s\S]*<\/subagent-notification>$/i, /<subagent-notification>/i],
+	] as const;
+	return content.every(part => {
+		if (!part || typeof part !== "object") return false;
+		const candidate = part as { type?: unknown; text?: unknown };
+		if (candidate.type === "input_image") return true;
+		if (candidate.type !== "input_text" || typeof candidate.text !== "string") return false;
+		const trimmed = candidate.text.trim();
+		if (trimmed.length === 0) return false;
+		return !contextualFragmentPatterns.some(([strictPattern, markerPattern]) => {
+			return strictPattern.test(trimmed) || markerPattern.test(trimmed);
+		});
+	});
+}
+
+function shouldKeepOpenAiCompactOutputItem(item: Record<string, unknown>): boolean {
+	if (item.type === "compaction" || item.type === "compaction_summary") return true;
+	if (item.type !== "message") return false;
+	if (item.role === "developer") return false;
+	if (item.role === "assistant") return true;
+	return shouldKeepOpenAiCompactOutputUserMessage(item);
+}
+
+function trimOpenAiCompactInput(
+	input: Array<Record<string, unknown>>,
+	contextWindow: number,
+	instructions: string,
+): Array<Record<string, unknown>> {
+	const trimmed = [...input];
+	while (trimmed.length > 0 && estimateOpenAiCompactInputTokens(trimmed, instructions) > contextWindow) {
+		const last = trimmed[trimmed.length - 1];
+		if (last?.type === "function_call_output") {
+			const callId = typeof last.call_id === "string" ? last.call_id : undefined;
+			trimmed.pop();
+			if (callId) {
+				const matchingCallIndex = trimmed.findLastIndex(
+					item => item.type === "function_call" && item.call_id === callId,
+				);
+				if (matchingCallIndex >= 0) {
+					trimmed.splice(matchingCallIndex, 1);
+				}
+			}
+			continue;
+		}
+		if (!last || !shouldTrimOpenAiCompactInputItem(last)) {
+			break;
+		}
+		trimmed.pop();
+	}
+	return trimmed;
+}
+
+function getOpenAIResponsesHistoryItems(
+	providerPayload: { type?: string; items?: unknown } | undefined,
+): Array<Record<string, unknown>> | undefined {
+	if (providerPayload?.type !== "openaiResponsesHistory" || !Array.isArray(providerPayload.items)) {
+		return undefined;
+	}
+	return providerPayload.items as Array<Record<string, unknown>>;
+}
+
+function collectKnownOpenAiCallIds(items: Array<Record<string, unknown>>): Set<string> {
+	const knownCallIds = new Set<string>();
+	for (const item of items) {
+		if (item.type === "function_call" && typeof item.call_id === "string") {
+			knownCallIds.add(item.call_id);
+		}
+	}
+	return knownCallIds;
+}
+
+function buildOpenAiNativeHistory(
+	messages: AgentMessage[],
+	model: Model,
+	previousReplacementHistory?: Array<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+	const input: Array<Record<string, unknown>> = previousReplacementHistory ? [...previousReplacementHistory] : [];
+	const transformedMessages = transformMessages(convertToLlm(messages), model, id =>
+		normalizeOpenAiCompactionToolCallId(id),
+	);
+
+	let msgIndex = 0;
+	let knownCallIds = collectKnownOpenAiCallIds(input);
+	for (const message of transformedMessages) {
+		if (message.role === "user" || message.role === "developer") {
+			const providerPayload = (message as { providerPayload?: { type?: string; items?: unknown } }).providerPayload;
+			const historyItems = getOpenAIResponsesHistoryItems(providerPayload);
+			if (historyItems) {
+				input.push(...historyItems);
+				knownCallIds = collectKnownOpenAiCallIds(input);
+				msgIndex++;
+				continue;
+			}
+
+			const contentBlocks: Array<Record<string, unknown>> = [];
+			if (typeof message.content === "string") {
+				if (message.content.trim().length > 0) {
+					contentBlocks.push({ type: "input_text", text: message.content.toWellFormed() });
+				}
+			} else {
+				for (const block of message.content) {
+					if (block.type === "text") {
+						if (!block.text || block.text.trim().length === 0) continue;
+						contentBlocks.push({ type: "input_text", text: block.text.toWellFormed() });
+						continue;
+					}
+					if (block.type === "image") {
+						contentBlocks.push({
+							type: "input_image",
+							detail: "auto",
+							image_url: `data:${block.mimeType};base64,${block.data}`,
+						});
+					}
+				}
+			}
+			if (contentBlocks.length > 0) {
+				input.push({ type: "message", role: message.role, content: contentBlocks });
+			}
+			msgIndex++;
+			continue;
+		}
+
+		if (message.role === "assistant") {
+			const providerPayload = (
+				message as { providerPayload?: { type?: string; incremental?: boolean; items?: unknown } }
+			).providerPayload;
+			const historyItems = getOpenAIResponsesHistoryItems(providerPayload);
+			if (historyItems) {
+				if (providerPayload?.incremental) {
+					input.push(...historyItems);
+				} else {
+					input.splice(0, input.length, ...historyItems);
+				}
+				knownCallIds = collectKnownOpenAiCallIds(input);
+				msgIndex++;
+				continue;
+			}
+
+			const assistant = message as AssistantMessage;
+			const isDifferentModel =
+				assistant.model !== model.id && assistant.provider === model.provider && assistant.api === model.api;
+
+			for (const block of assistant.content) {
+				if (block.type === "thinking" && assistant.stopReason !== "error" && block.thinkingSignature) {
+					try {
+						const reasoningItem = JSON.parse(block.thinkingSignature) as Record<string, unknown>;
+						if (reasoningItem && typeof reasoningItem === "object") {
+							input.push(reasoningItem);
+						}
+					} catch {
+						logger.warn("Failed to parse assistant reasoning for remote compaction", {
+							model: assistant.model,
+							provider: assistant.provider,
+						});
+					}
+					continue;
+				}
+
+				if (block.type === "text") {
+					if (!block.text || block.text.trim().length === 0) continue;
+					let msgId = block.textSignature;
+					if (!msgId) {
+						msgId = `msg_${msgIndex}`;
+					} else if (msgId.length > 64) {
+						msgId = `msg_${Bun.hash.xxHash64(msgId).toString(36)}`;
+					}
+					input.push({
+						type: "message",
+						role: "assistant",
+						content: [{ type: "output_text", text: block.text.toWellFormed(), annotations: [] }],
+						status: "completed",
+						id: msgId,
+					});
+					continue;
+				}
+
+				if (block.type === "toolCall" && assistant.stopReason !== "error") {
+					const normalized = normalizeResponsesToolCallId(block.id);
+					let itemId: string | undefined = normalized.itemId;
+					if (isDifferentModel && (itemId?.startsWith("fc_") || itemId?.startsWith("fcr_"))) {
+						itemId = undefined;
+					}
+					knownCallIds.add(normalized.callId);
+					input.push({
+						type: "function_call",
+						id: itemId,
+						call_id: normalized.callId,
+						name: block.name,
+						arguments: JSON.stringify(block.arguments),
+					});
+				}
+			}
+
+			msgIndex++;
+			continue;
+		}
+
+		if (message.role === "toolResult") {
+			const normalized = normalizeResponsesToolCallId(message.toolCallId);
+			if (!knownCallIds.has(normalized.callId)) {
+				msgIndex++;
+				continue;
+			}
+
+			const textOutput = message.content
+				.filter(block => block.type === "text")
+				.map(block => block.text)
+				.join("\n");
+			const hasImages = message.content.some(block => block.type === "image");
+			input.push({
+				type: "function_call_output",
+				call_id: normalized.callId,
+				output: (textOutput.length > 0 ? textOutput : "(see attached image)").toWellFormed(),
+			});
+
+			if (hasImages && model.input.includes("image")) {
+				const contentBlocks: Array<Record<string, unknown>> = [
+					{ type: "input_text", text: "Attached image(s) from tool result:" },
+				];
+				for (const block of message.content) {
+					if (block.type !== "image") continue;
+					contentBlocks.push({
+						type: "input_image",
+						detail: "auto",
+						image_url: `data:${block.mimeType};base64,${block.data}`,
+					});
+				}
+				input.push({ type: "message", role: "user", content: contentBlocks });
+			}
+		}
+
+		msgIndex++;
+	}
+
+	return input;
+}
+
+async function requestOpenAiRemoteCompaction(
+	model: Model,
+	apiKey: string,
+	compactInput: Array<Record<string, unknown>>,
+	instructions: string,
+): Promise<OpenAiRemoteCompactionResponse> {
+	const endpoint = resolveOpenAiCompactEndpoint(model);
+	const request: OpenAiRemoteCompactionRequest = {
+		model: model.id,
+		input: trimOpenAiCompactInput(compactInput, model.contextWindow, instructions),
+		instructions,
+	};
+	const headers: Record<string, string> = {
+		"content-type": "application/json",
+		Authorization: `Bearer ${apiKey}`,
+		...(model.headers ?? {}),
+	};
+
+	// Codex endpoints require additional auth headers
+	if (model.provider === "openai-codex") {
+		const accountId = getCodexAccountId(apiKey);
+		if (accountId) {
+			headers[OPENAI_HEADERS.ACCOUNT_ID] = accountId;
+		}
+		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
+		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
+	}
+
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(request),
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text().catch(() => "");
+		logger.warn("OpenAI remote compaction failed", {
+			endpoint,
+			status: response.status,
+			statusText: response.statusText,
+			errorText,
+		});
+		throw new Error(`Remote compaction failed (${response.status} ${response.statusText})`);
+	}
+
+	const data = (await response.json()) as { output?: unknown[] } | undefined;
+	const rawOutput = data?.output ?? [];
+	const replacementHistory = rawOutput.filter(
+		(item): item is Record<string, unknown> =>
+			!!item && typeof item === "object" && shouldKeepOpenAiCompactOutputItem(item as Record<string, unknown>),
+	);
+	const compactionItem = [...replacementHistory].reverse().find((item): item is OpenAiRemoteCompactionItem => {
+		if (item.type === "compaction" && typeof item.encrypted_content === "string") return true;
+		if (item.type === "compaction_summary") return true;
+		return false;
+	});
+	if (!compactionItem) {
+		const outputTypes = rawOutput.map(item =>
+			typeof item === "object" && item !== null ? (item as Record<string, unknown>).type : typeof item,
+		);
+		logger.warn("Remote compaction response missing compaction item", {
+			endpoint,
+			model: model.id,
+			provider: model.provider,
+			rawOutputLength: rawOutput.length,
+			outputTypes,
+			replacementHistoryLength: replacementHistory.length,
+		});
+		throw new Error("Remote compaction response missing compaction item");
+	}
+	return { replacementHistory, compactionItem };
+}
+
+interface RemoteCompactionRequest {
+	systemPrompt: string;
+	prompt: string;
+}
+
 async function requestRemoteCompaction(
 	endpoint: string,
 	request: RemoteCompactionRequest,
@@ -488,6 +934,7 @@ export interface SummaryOptions {
 	promptOverride?: string;
 	extraContext?: string[];
 	remoteEndpoint?: string;
+	remoteInstructions?: string;
 }
 
 export async function generateSummary(
@@ -543,7 +990,7 @@ export async function generateSummary(
 	const response = await completeSimple(
 		model,
 		{ systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages },
-		{ maxTokens, signal, apiKey, reasoning: "high" },
+		{ maxTokens, signal, apiKey, reasoning: Effort.High },
 	);
 
 	if (response.stopReason === "error") {
@@ -592,7 +1039,7 @@ async function generateShortSummary(
 			systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
 			messages: [{ role: "user", content: [{ type: "text", text: promptText }], timestamp: Date.now() }],
 		},
-		{ maxTokens, signal, apiKey, reasoning: "high" },
+		{ maxTokens, signal, apiKey, reasoning: Effort.High },
 	);
 
 	if (response.stopReason === "error") {
@@ -623,6 +1070,8 @@ export interface CompactionPreparation {
 	tokensBefore: number;
 	/** Summary from previous compaction, for iterative update */
 	previousSummary?: string;
+	/** Preserved opaque compaction payload from the previous compaction, if any. */
+	previousPreserveData?: Record<string, unknown>;
 	/** File operations extracted from messagesToSummarize */
 	fileOps: FileOperations;
 	/** Compaction settions from settings.jsonl	*/
@@ -692,12 +1141,18 @@ export function prepareCompaction(
 		const msg = getMessageFromEntry(pathEntries[i]);
 		if (msg) recentMessages.push(msg);
 	}
+	// Nothing to summarize means compaction would be a no-op.
+	if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
+		return undefined;
+	}
 
-	// Get previous summary for iterative update
+	// Get previous summary and preserved data for iterative updates
 	let previousSummary: string | undefined;
+	let previousPreserveData: Record<string, unknown> | undefined;
 	if (prevCompactionIndex >= 0) {
 		const prevCompaction = pathEntries[prevCompactionIndex] as CompactionEntry;
 		previousSummary = prevCompaction.summary;
+		previousPreserveData = prevCompaction.preserveData;
 	}
 
 	// Extract file operations from messages and previous compaction
@@ -718,6 +1173,7 @@ export function prepareCompaction(
 		isSplitTurn: cutPoint.isSplitTurn,
 		tokensBefore,
 		previousSummary,
+		previousPreserveData,
 		fileOps,
 		settings,
 	};
@@ -752,6 +1208,7 @@ export async function compact(
 		isSplitTurn,
 		tokensBefore,
 		previousSummary,
+		previousPreserveData,
 		fileOps,
 		settings,
 	} = preparation;
@@ -759,9 +1216,38 @@ export async function compact(
 	const summaryOptions: SummaryOptions = {
 		promptOverride: options?.promptOverride,
 		extraContext: options?.extraContext,
-		remoteEndpoint: settings.remoteEndpoint,
+		remoteEndpoint: settings.remoteEnabled === false ? undefined : settings.remoteEndpoint,
+		remoteInstructions: options?.remoteInstructions,
 	};
 
+	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
+	if (settings.remoteEnabled !== false && shouldUseOpenAiRemoteCompaction(model)) {
+		const previousRemoteCompaction = getPreservedOpenAiRemoteCompactionData(previousPreserveData);
+		const remoteMessages = [...messagesToSummarize, ...turnPrefixMessages, ...recentMessages];
+		const remoteHistory = buildOpenAiNativeHistory(
+			remoteMessages,
+			model,
+			previousRemoteCompaction?.replacementHistory,
+		);
+		if (remoteHistory.length > 0) {
+			try {
+				const remote = await requestOpenAiRemoteCompaction(
+					model,
+					apiKey,
+					remoteHistory,
+					summaryOptions.remoteInstructions ?? SUMMARIZATION_SYSTEM_PROMPT,
+				);
+				preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, remote);
+			} catch (err) {
+				logger.warn("OpenAI remote compaction failed, falling back to local summarization", {
+					error: err instanceof Error ? err.message : String(err),
+					model: model.id,
+					provider: model.provider,
+				});
+			}
+		}
+	}
+
 	// Generate summaries (can be parallel if both needed) and merge into one
 	let summary: string;
 
@@ -811,7 +1297,7 @@ export async function compact(
 		settings.reserveTokens,
 		apiKey,
 		signal,
-		{ extraContext: options?.extraContext, remoteEndpoint: settings.remoteEndpoint },
+		{ extraContext: options?.extraContext, remoteEndpoint: summaryOptions.remoteEndpoint },
 	);
 
 	// Compute file lists and append to summary
@@ -828,6 +1314,7 @@ export async function compact(
 		firstKeptEntryId,
 		tokensBefore,
 		details: { readFiles, modifiedFiles } as CompactionDetails,
+		preserveData,
 	};
 }
 
@@ -857,7 +1344,7 @@ async function generateTurnPrefixSummary(
 	const response = await completeSimple(
 		model,
 		{ systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages },
-		{ maxTokens, signal, apiKey, reasoning: "high" },
+		{ maxTokens, signal, apiKey, reasoning: Effort.High },
 	);
 
 	if (response.stopReason === "error") {