@howaboua/pi-codex-conversion 1.5.5 → 1.5.6-dev.28.300a94c

package/src/adapter/provider-request.ts

@@ -5,8 +5,9 @@ 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";
 
-export function rewriteCodexProviderRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): unknown | undefined {
+export async function rewriteCodexProviderRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): Promise<unknown | undefined> {
 	if (!shouldUseCodexAdapter(ctx, state.config) || (!isOpenAICodexContext(ctx) && !isResponsesContext(ctx))) {
 		return undefined;
 	}
@@ -16,8 +17,9 @@ export function rewriteCodexProviderRequest(payload: unknown, ctx: ExtensionCont
 	const imageGenerationPayload = isOpenAICodex && state.config.imageGeneration
 		? rewriteNativeImageGenerationTool(webSearchPayload, ctx.model)
 		: webSearchPayload;
-	return applyCodexRequestParams(imageGenerationPayload, state.config, {
+	const configuredPayload = applyCodexRequestParams(imageGenerationPayload, state.config, {
 		serviceTier: isOpenAICodex,
 		verbosity: true,
 	});
+	return (await rewriteCodexCompactedProviderRequest(configuredPayload, ctx, state)) ?? configuredPayload;
 }

package/src/adapter/serializer.ts

@@ -0,0 +1,288 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { convertToLlm, getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { Api, ImageContent, Message, Model, TextContent, ToolResultMessage, UserMessage } from "@earendil-works/pi-ai";
+import type { ResponsesCompatibleRequestPayload } from "./compaction-runtime.ts";
+import { CODEX_TOOL_CALL_PROVIDERS, convertResponsesMessages } from "../providers/openai-responses-shared.ts";
+
+/**
+ * Decision for native compaction: reuse the provider's Responses serializer.
+ *
+ * Replay parity must match the actual OpenAI Codex provider payload, including
+ * tool-call id normalization and cross-model/provider history handling.
+ */
+export const COMPACTION_SERIALIZER_STRATEGY = "provider-responses-serializer" as const;
+
+export type CompactionSerializerStrategy = typeof COMPACTION_SERIALIZER_STRATEGY;
+export type AssistantPhase = "commentary" | "final_answer";
+
+type ResponsesTextInputItem = {
+	type: "input_text";
+	text: string;
+};
+
+type ResponsesImageInputItem = {
+	type: "input_image";
+	detail: "auto";
+	image_url: string;
+};
+
+export type ResponsesInputContentItem = ResponsesTextInputItem | ResponsesImageInputItem;
+
+export type ResponsesInputMessageItem = {
+	role: "user" | "developer" | "system";
+	content: ResponsesInputContentItem[] | string;
+};
+
+export type ResponsesAssistantOutputItem = {
+	type: "message";
+	role: "assistant";
+	content: Array<{
+		type: "output_text";
+		text: string;
+		annotations: [];
+	}>;
+	status: "completed";
+	id: string;
+	phase?: AssistantPhase;
+};
+
+export type ResponsesFunctionCallItem = {
+	type: "function_call";
+	id?: string;
+	call_id: string;
+	name: string;
+	arguments: string;
+};
+
+export type ResponsesFunctionCallOutputItem = {
+	type: "function_call_output";
+	call_id: string;
+	output: ResponsesInputContentItem[] | string;
+};
+
+export type ResponsesReasoningItem = Record<string, unknown>;
+
+export type ResponsesInputItem =
+	| ResponsesInputMessageItem
+	| ResponsesAssistantOutputItem
+	| ResponsesFunctionCallItem
+	| ResponsesFunctionCallOutputItem
+	| ResponsesReasoningItem;
+
+export type NativeCompactionRequestBody = {
+	model: string;
+	input: ResponsesInputItem[];
+	instructions: string;
+	parallel_tool_calls?: boolean;
+	prompt_cache_key?: string;
+	service_tier?: string;
+	text?: { verbosity: string };
+	tools?: unknown[];
+	reasoning?: unknown;
+};
+
+export type NativeCompactionRequestOptions = Pick<
+	NativeCompactionRequestBody,
+	"parallel_tool_calls" | "prompt_cache_key" | "service_tier" | "text" | "tools" | "reasoning"
+>;
+
+export type SerializeResponsesMessagesOptions = {
+	instructions?: string;
+	includeInstructionsInInput?: boolean;
+	blockImages?: boolean;
+};
+
+export type ResponsesParityReport = {
+	ok: boolean;
+	actual: string[];
+	expected: string[];
+	mismatches: string[];
+};
+
+
+function sanitizeSurrogates(text: string): string {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+let cachedBlockImagesSetting: boolean | undefined;
+
+function readBlockImagesSetting(): boolean {
+	if (cachedBlockImagesSetting !== undefined) return cachedBlockImagesSetting;
+	try {
+		const parsed = JSON.parse(readFileSync(join(getAgentDir(), "settings.json"), "utf-8")) as unknown;
+		cachedBlockImagesSetting = isRecord(parsed) && isRecord(parsed.images) && parsed.images.blockImages === true;
+	} catch {
+		cachedBlockImagesSetting = false;
+	}
+	return cachedBlockImagesSetting;
+}
+
+function replaceImagesWithDisabledPlaceholder<TMessage extends UserMessage | ToolResultMessage>(message: TMessage): TMessage {
+	if (!Array.isArray(message.content) || !message.content.some((item) => item.type === "image")) return message;
+	const content = message.content
+		.map((item): TextContent | ImageContent => item.type === "image" ? { type: "text", text: "Image reading is disabled." } : item)
+		.filter((item, index, items) => {
+			const previous = items[index - 1];
+			return !(item.type === "text" && item.text === "Image reading is disabled." && previous?.type === "text" && previous.text === "Image reading is disabled.");
+		});
+	return { ...message, content };
+}
+
+function applyBlockImages(messages: Message[], blockImages: boolean): Message[] {
+	if (!blockImages) return messages;
+	return messages.map((message) => {
+		if (message.role === "user" || message.role === "toolResult") return replaceImagesWithDisabledPlaceholder(message);
+		return message;
+	});
+}
+
+type CompactionPreparationLike = { messagesToSummarize: AgentMessage[]; turnPrefixMessages: AgentMessage[]; previousSummary?: string };
+
+export function collectCompactionWindowMessages(preparation: CompactionPreparationLike): AgentMessage[] {
+	const previousSummary = preparation.previousSummary?.trim();
+	const previousSummaryMessages: AgentMessage[] = previousSummary
+		? [
+				{
+					role: "user",
+					content: `Previous compaction summary:\n${previousSummary}`,
+					timestamp: Date.now(),
+				} as AgentMessage,
+			]
+		: [];
+	return [...previousSummaryMessages, ...preparation.messagesToSummarize, ...preparation.turnPrefixMessages];
+}
+
+export function serializeCompactionPreparationToRequest<TApi extends Api>(args: {
+	model: Model<TApi>;
+	preparation: CompactionPreparationLike;
+	instructions: string;
+	requestOptions?: NativeCompactionRequestOptions;
+}): NativeCompactionRequestBody {
+	return serializeMessagesToCompactRequest({
+		model: args.model,
+		messages: collectCompactionWindowMessages(args.preparation),
+		instructions: args.instructions,
+		requestOptions: args.requestOptions,
+	});
+}
+
+export function serializeMessagesToCompactRequest<TApi extends Api>(args: {
+	model: Model<TApi>;
+	messages: AgentMessage[];
+	instructions: string;
+	requestOptions?: NativeCompactionRequestOptions;
+}): NativeCompactionRequestBody {
+	return {
+		model: args.model.id,
+		input: serializeMessagesToResponsesInput(args.model, args.messages),
+		instructions: sanitizeSurrogates(args.instructions),
+		...args.requestOptions,
+	};
+}
+
+export function serializeMessagesToResponsesInput<TApi extends Api>(
+	model: Model<TApi>,
+	messages: AgentMessage[],
+	options: SerializeResponsesMessagesOptions = {},
+): ResponsesInputItem[] {
+	const llmMessages = applyBlockImages(convertToLlm(messages), options.blockImages ?? readBlockImagesSetting());
+	return convertResponsesMessages(
+		model,
+		{
+			messages: llmMessages,
+			...(options.includeInstructionsInInput && options.instructions ? { systemPrompt: options.instructions } : {}),
+		},
+		CODEX_TOOL_CALL_PROVIDERS,
+		{ includeSystemPrompt: options.includeInstructionsInInput ?? false },
+	) as ResponsesInputItem[];
+}
+
+export function createResponsesInputParitySignature(input: readonly unknown[]): string[] {
+	return input.map(describeResponsesInputItem);
+}
+
+export function compareResponsesInputParity(actual: readonly unknown[], expected: readonly unknown[]): ResponsesParityReport {
+	const actualSignature = createResponsesInputParitySignature(actual);
+	const expectedSignature = createResponsesInputParitySignature(expected);
+	const maxLength = Math.max(actualSignature.length, expectedSignature.length);
+	const mismatches: string[] = [];
+
+	for (let index = 0; index < maxLength; index++) {
+		const actualValue = actualSignature[index];
+		const expectedValue = expectedSignature[index];
+		if (actualValue !== expectedValue) {
+			mismatches.push(`index ${index}: expected ${expectedValue ?? "<missing>"}, got ${actualValue ?? "<missing>"}`);
+		}
+	}
+
+	return {
+		ok: mismatches.length === 0,
+		actual: actualSignature,
+		expected: expectedSignature,
+		mismatches,
+	};
+}
+
+export function compareCompactRequestToPayload(
+	request: NativeCompactionRequestBody,
+	payload: Pick<ResponsesCompatibleRequestPayload, "model" | "input" | "instructions">,
+): ResponsesParityReport {
+	const parity = compareResponsesInputParity(request.input, payload.input);
+	const mismatches = [...parity.mismatches];
+
+	if (payload.model !== request.model) {
+		mismatches.unshift(`model: expected ${payload.model}, got ${request.model}`);
+	}
+
+	if ((payload.instructions ?? "") !== request.instructions) {
+		mismatches.unshift("instructions: expected serialized instructions to match payload instructions");
+	}
+
+	return {
+		ok: mismatches.length === 0,
+		actual: parity.actual,
+		expected: parity.expected,
+		mismatches,
+	};
+}
+
+function describeResponsesInputItem(item: unknown): string {
+	if (!item || typeof item !== "object" || Array.isArray(item)) {
+		return typeof item;
+	}
+
+	const record = item as Record<string, unknown>;
+	const type = typeof record.type === "string" ? record.type : undefined;
+	if (type === "message") {
+		const phase =
+			record.phase === "commentary" || record.phase === "final_answer"
+				? `:${record.phase}`
+				: "";
+		return `message:${typeof record.role === "string" ? record.role : "unknown"}${phase}`;
+	}
+
+	if (type === "function_call") {
+		return `function_call:${typeof record.name === "string" ? record.name : "unknown"}`;
+	}
+
+	if (type === "function_call_output") {
+		return "function_call_output";
+	}
+
+	if (type === "reasoning") {
+		return "reasoning";
+	}
+
+	if (typeof record.role === "string") {
+		const content = Array.isArray(record.content) ? `[${record.content.length}]` : "";
+		return `input:${record.role}${content}`;
+	}
+
+	return type ? `item:${type}` : "object";
+}

package/src/adapter/skills.ts

@@ -15,3 +15,11 @@ export function getCodexSkillPaths(cwd: string, home: string = homedir()): strin
 	}
 	return skillPaths.filter((path) => existsSync(path));
 }
+
+export function hasNoSkillsFlag(argv: readonly string[] = process.argv): boolean {
+	for (const arg of argv) {
+		if (arg === "--") return false;
+		if (arg === "--no-skills" || arg === "-ns") return true;
+	}
+	return false;
+}

package/src/adapter/tool-set.ts

@@ -1,11 +1,13 @@
 export const STATUS_KEY = "codex-adapter";
 export const STATUS_TEXT = "\u001b[38;2;0;76;255mCodex adapter\u001b[0m";
+export const APPLY_PATCH_ONLY_STATUS_TEXT = `${STATUS_TEXT} • apply patch only`;
 
-export function buildStatusText(options: { verbosity?: string; webSearch: boolean; imageGeneration: boolean; fast: boolean; useOnAllModels: boolean }): string {
+export function buildStatusText(options: { verbosity?: string; webSearch: boolean; imageGeneration: boolean; fast: boolean; useOnAllModels: boolean; compaction?: { enabled: boolean; model: string; reasoning: string } }): string {
 	const extras = [
 		options.useOnAllModels ? "all models" : undefined,
 		options.webSearch ? "web search" : undefined,
 		options.imageGeneration ? "image gen" : undefined,
+		options.compaction?.enabled ? `compact ${options.compaction.model}/${options.compaction.reasoning}` : undefined,
 		options.fast ? "fast" : undefined,
 	]
 		.filter(Boolean)
@@ -16,7 +18,9 @@ export function buildStatusText(options: { verbosity?: string; webSearch: boolea
 
 export const DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write"];
 
-export const CORE_ADAPTER_TOOL_NAMES = ["exec_command", "write_stdin", "apply_patch"];
+export const SHELL_ADAPTER_TOOL_NAMES = ["exec_command", "write_stdin"];
+export const APPLY_PATCH_TOOL_NAME = "apply_patch";
+export const CORE_ADAPTER_TOOL_NAMES = [...SHELL_ADAPTER_TOOL_NAMES, APPLY_PATCH_TOOL_NAME];
 export const IMAGE_GENERATION_TOOL_NAME = "image_generation";
 export const VIEW_IMAGE_TOOL_NAME = "view_image";
-export const WEB_SEARCH_TOOL_NAME = "web_search";
+export const WEB_SEARCH_TOOL_NAME = "web.run";

package/src/adapter/types.ts

@@ -0,0 +1,220 @@
+import type { CompactionEntry, CompactionResult } from "@earendil-works/pi-coding-agent";
+
+export const EXTENSION_ID = "openai-native-compaction";
+export const NATIVE_COMPACTION_STRATEGY = "openai-native-compact-v1";
+export const NATIVE_COMPACTION_SHIM_SUMMARY = "[OpenAI native compaction checkpoint]";
+export const NATIVE_COMPACTION_DISPLAY_MESSAGE_TYPE = "codex-native-compaction-display";
+export const NATIVE_COMPACTION_DISPLAY_TEXT = [
+	"Codex native compaction was used for this checkpoint.",
+	"",
+	"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.",
+].join("\n");
+
+export type NativeCompactionStrategy = typeof NATIVE_COMPACTION_STRATEGY;
+export type NativeCompactionShimSummary = typeof NATIVE_COMPACTION_SHIM_SUMMARY;
+
+export type NativeCompactionRequestMeta = {
+	tokensBefore?: number;
+	previousSummaryPresent?: boolean;
+	compactedKeptWindow?: boolean;
+};
+
+export type NativeCompactionIdentity = {
+	provider: string;
+	api: string;
+	model: string;
+	baseUrl: string;
+};
+
+export type NativeCompactionDetails = NativeCompactionIdentity & {
+	strategy: NativeCompactionStrategy;
+	compactedWindow: unknown[];
+	compactResponseId?: string;
+	createdAt: string;
+	requestMeta?: NativeCompactionRequestMeta;
+};
+
+export type NativeCompactionEntry = CompactionEntry<NativeCompactionDetails>;
+
+export type CreateNativeCompactionDetailsInput = NativeCompactionIdentity & {
+	compactedWindow: unknown[];
+	compactResponseId?: string;
+	createdAt?: string;
+	requestMeta?: NativeCompactionRequestMeta;
+};
+
+export type CreateNativeCompactionShimResultInput = {
+	summary: string;
+	firstKeptEntryId: string;
+	tokensBefore: number;
+	details: NativeCompactionDetails;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.trim().length > 0;
+}
+
+function isFiniteNonNegativeNumber(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function normalizeString(value: string): string {
+	return value.trim();
+}
+
+function isStructuredValue(value: unknown): boolean {
+	if (
+		value === null ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean"
+	) {
+		return true;
+	}
+
+	if (Array.isArray(value)) {
+		return value.every(isStructuredValue);
+	}
+
+	if (isRecord(value)) {
+		return Object.values(value).every(isStructuredValue);
+	}
+
+	return false;
+}
+
+function cloneStructuredValue(value: unknown): unknown {
+	if (
+		value === null ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean"
+	) {
+		return value;
+	}
+
+	if (Array.isArray(value)) {
+		return value.map(cloneStructuredValue);
+	}
+
+	if (isRecord(value)) {
+		const clone: Record<string, unknown> = {};
+		for (const [key, nested] of Object.entries(value)) {
+			clone[key] = cloneStructuredValue(nested);
+		}
+		return clone;
+	}
+
+	throw new Error(`Unsupported structured value: ${typeof value}`);
+}
+
+function isCompactedWindowItem(value: unknown): value is Record<string, unknown> {
+	return isRecord(value) && Object.values(value).every(isStructuredValue);
+}
+
+export function isNativeCompactionRequestMeta(value: unknown): value is NativeCompactionRequestMeta {
+	if (!isRecord(value)) {
+		return false;
+	}
+
+	const { tokensBefore, previousSummaryPresent, compactedKeptWindow } = value;
+	if (tokensBefore !== undefined && !isFiniteNonNegativeNumber(tokensBefore)) {
+		return false;
+	}
+
+	if (previousSummaryPresent !== undefined && typeof previousSummaryPresent !== "boolean") {
+		return false;
+	}
+
+	if (compactedKeptWindow !== undefined && typeof compactedKeptWindow !== "boolean") {
+		return false;
+	}
+
+	return true;
+}
+
+export function isNativeCompactionIdentity(value: unknown): value is NativeCompactionIdentity {
+	if (!isRecord(value)) {
+		return false;
+	}
+
+	return (
+		isNonEmptyString(value.provider) &&
+		isNonEmptyString(value.api) &&
+		isNonEmptyString(value.model) &&
+		isNonEmptyString(value.baseUrl)
+	);
+}
+
+export function isNativeCompactionDetails(value: unknown): value is NativeCompactionDetails {
+	if (!isRecord(value)) {
+		return false;
+	}
+	const candidate = value as Record<string, unknown>;
+
+	return (
+		candidate.strategy === NATIVE_COMPACTION_STRATEGY &&
+		isNonEmptyString(candidate.provider) &&
+		isNonEmptyString(candidate.api) &&
+		isNonEmptyString(candidate.model) &&
+		isNonEmptyString(candidate.baseUrl) &&
+		Array.isArray(candidate.compactedWindow) &&
+		candidate.compactedWindow.every(isCompactedWindowItem) &&
+		isNonEmptyString(candidate.createdAt) &&
+		(candidate.compactResponseId === undefined || isNonEmptyString(candidate.compactResponseId)) &&
+		(candidate.requestMeta === undefined || isNativeCompactionRequestMeta(candidate.requestMeta))
+	);
+}
+
+export function isNativeCompactionEntry(value: unknown): value is NativeCompactionEntry {
+	return isRecord(value) && value.type === "compaction" && isNativeCompactionDetails(value.details);
+}
+
+export function isNativeCompactionShimSummary(value: unknown): value is NativeCompactionShimSummary {
+	return value === NATIVE_COMPACTION_SHIM_SUMMARY;
+}
+
+export function createNativeCompactionDetails(input: CreateNativeCompactionDetailsInput): NativeCompactionDetails {
+	return {
+		strategy: NATIVE_COMPACTION_STRATEGY,
+		provider: normalizeString(input.provider),
+		api: normalizeString(input.api),
+		model: normalizeString(input.model),
+		baseUrl: normalizeString(input.baseUrl),
+		compactedWindow: input.compactedWindow.map((item) => cloneStructuredValue(item)),
+		compactResponseId: isNonEmptyString(input.compactResponseId) ? normalizeString(input.compactResponseId) : undefined,
+		createdAt: isNonEmptyString(input.createdAt) ? normalizeString(input.createdAt) : new Date().toISOString(),
+		requestMeta: input.requestMeta
+			? {
+				...(input.requestMeta.tokensBefore !== undefined ? { tokensBefore: input.requestMeta.tokensBefore } : {}),
+				...(input.requestMeta.previousSummaryPresent !== undefined
+					? { previousSummaryPresent: input.requestMeta.previousSummaryPresent }
+					: {}),
+				...(input.requestMeta.compactedKeptWindow !== undefined
+					? { compactedKeptWindow: input.requestMeta.compactedKeptWindow }
+					: {}),
+			}
+			: undefined,
+	};
+}
+
+export function createNativeCompactionShimSummary(): NativeCompactionShimSummary {
+	return NATIVE_COMPACTION_SHIM_SUMMARY;
+}
+
+export function createNativeCompactionShimResult(
+	input: CreateNativeCompactionShimResultInput,
+): CompactionResult<NativeCompactionDetails> {
+	return {
+		summary: input.summary,
+		firstKeptEntryId: input.firstKeptEntryId,
+		tokensBefore: input.tokensBefore,
+		details: input.details,
+	};
+}

package/src/codex-settings/command.ts

@@ -9,7 +9,8 @@ import { syncAdapter } from "../adapter/activation.ts";
 import type { AdapterState } from "../adapter/state.ts";
 import { openCodexSettingsScreen } from "./ui.ts";
 
-const CODEX_COMMAND_COMPLETIONS = ["all", "status", "fast", "search", "image", "low", "medium", "high"] as const;
+const CODEX_COMMAND_COMPLETIONS = ["all", "status", "fast", "search", "image", "compact", "low", "medium", "high"] as const;
+const CODEX_USAGE = "Usage: /codex, /codex all, /codex status, /codex fast, /codex search, /codex image, /codex compact, /codex low|medium|high";
 
 export function registerCodexCommand(pi: ExtensionAPI, state: AdapterState, onConfigApplied?: (config: CodexConversionConfig) => void): void {
 	function saveAndApply(ctx: ExtensionContext, nextConfig: CodexConversionConfig): boolean {
@@ -31,6 +32,18 @@ export function registerCodexCommand(pi: ExtensionAPI, state: AdapterState, onCo
 		handler: async (args, ctx) => {
 			state.config = readCodexConversionConfig();
 			const arg = args.trim().toLowerCase();
+			if (arg === "compact") {
+				if (!ctx.hasUI) {
+					ctx.ui.notify(formatCodexSettings(state.config), "info");
+					return;
+				}
+				await openCodexSettingsScreen(ctx, {
+					initialConfig: state.config,
+					initialTab: "compaction",
+					onChange: (config) => saveAndApply(ctx, config),
+				});
+				return;
+			}
 			const nextConfig = getCommandConfigUpdate(arg, state.config);
 			if (nextConfig) {
 				saveAndApply(ctx, nextConfig);
@@ -38,7 +51,7 @@ export function registerCodexCommand(pi: ExtensionAPI, state: AdapterState, onCo
 			}
 
 			if (arg) {
-				ctx.ui.notify("Usage: /codex, /codex all, /codex status, /codex fast, /codex search, /codex image, /codex low|medium|high", "warning");
+				ctx.ui.notify(CODEX_USAGE, "warning");
 				return;
 			}
 
@@ -66,5 +79,5 @@ function getCommandConfigUpdate(arg: string, config: CodexConversionConfig): Cod
 }
 
 function formatCodexSettings(config: CodexConversionConfig): string {
-	return `Codex settings: all models ${config.useOnAllModels ? "on" : "off"}, statusline ${config.statusLine ? "on" : "off"}, fast ${config.fast ? "on" : "off"}, web search ${config.webSearch ? "on" : "off"}, image generation ${config.imageGeneration ? "on" : "off"}, verbosity ${config.verbosity}`;
+	return `Codex settings: all models ${config.useOnAllModels ? "on" : "off"}, statusline ${config.statusLine ? "on" : "off"}, fast ${config.fast ? "on" : "off"}, web search ${config.webSearch ? "on" : "off"}, image generation ${config.imageGeneration ? "on" : "off"}, responses compaction ${(config.responsesCompaction ?? false) ? "on" : "off"} (${config.compactionModel}/${config.compactionReasoning}), verbosity ${config.verbosity}`;
 }