compact_prompt is loaded but ignored for OpenAI remote compaction

Confirmed on 0.146.1 (ChatGPT auth, gpt-5.6-sol), with field evidence from a long-running thread.

Dispatch (pinned to rust-v0.146.1): both the manual task and the inline auto path gate on should_use_remote_compact_task = provider.supports_remote_compaction() (= is_openai() || azure), so the local arm — the only consumer of config.compact_prompt — is unreachable on the default provider:

• https://github.com/openai/codex/blob/rust-v0.146.1/codex-rs/core/src/tasks/compact.rs#L41
• https://github.com/openai/codex/blob/rust-v0.146.1/codex-rs/core/src/session/turn.rs#L1035
• https://github.com/openai/codex/blob/rust-v0.146.1/codex-rs/model-provider-info/src/lib.rs#L422-L424
• prompt consumed only here: https://github.com/openai/codex/blob/rust-v0.146.1/codex-rs/core/src/compact.rs#L118-L122 and https://github.com/openai/codex/blob/rust-v0.146.1/codex-rs/core/src/tasks/compact.rs#L67-L76

Rollout evidence: across 37 auto-compactions in one thread, every compacted event has payload.message == "" (hardcoded empty on the remote-v2 path) and replacement_history ends in an encrypted cmp_* compaction item; the configured prompt text never appears in any request.

Practical harm beyond the dead setting: with no client-visible distillate, the replacement history is the verbatim user turns. In our case a stale one-time directive ("pause and commit") retained as the last real user message re-steered a long campaign into an unwanted pause immediately after two consecutive compactions — exactly the failure mode a custom handoff prompt is written to prevent.

Until the setting is honored (or explicitly rejected), a startup warning when compact_prompt / experimental_compact_prompt_file is set while the provider uses remote compaction would at least prevent the silent no-op.

Related: #37305 — the local compaction path additionally omits tool specs from its request and therefore never hits the prompt cache; any fix that routes custom prompts to local compaction will surface that cost bug too.

I rechecked this on the official Codex CLI 0.150.1 source (rust-v0.150.1, commit 90854393966b21e9ebfd21b122334eb09a20c93d). The remote compaction paths still do not apply config.compact_prompt, although local compaction does.

Relevant paths:

• codex-rs/core/src/compact.rs — local compaction reads turn_context.config.compact_prompt
• codex-rs/core/src/compact_remote_request.rs — remote V1 uses only sess.get_base_instructions()
• codex-rs/core/src/compact_remote_v2_attempt.rs — remote V2 also uses only sess.get_base_instructions()
• codex-rs/core/src/compact_remote.rs — common remote-compaction module where a shared composition helper can live

The minimal change that makes V1 and V2 honor the configured compaction prompt while preserving the existing BaseInstructions provenance is:

diff --git a/codex-rs/core/src/compact_remote.rs b/codex-rs/core/src/compact_remote.rs
@@
+pub(crate) fn compose_remote_compaction_instructions(
+    base_instructions: BaseInstructions,
+    compact_prompt: Option<&str>,
+) -> BaseInstructions {
+    let Some(compact_prompt) = compact_prompt else {
+        return base_instructions;
+    };
+    let BaseInstructions {
+        mut text,
+        provenance,
+    } = base_instructions;
+    text.push_str("\n\n<custom_compaction_instructions>\n");
+    text.push_str(compact_prompt);
+    text.push_str("\n</custom_compaction_instructions>");
+    BaseInstructions { text, provenance }
+}

diff --git a/codex-rs/core/src/compact_remote_request.rs b/codex-rs/core/src/compact_remote_request.rs
@@
-    let base_instructions = sess.get_base_instructions().await;
+    let base_instructions = super::compose_remote_compaction_instructions(
+        sess.get_base_instructions().await,
+        turn_context.config.compact_prompt.as_deref(),
+    );

diff --git a/codex-rs/core/src/compact_remote_v2_attempt.rs b/codex-rs/core/src/compact_remote_v2_attempt.rs
@@
-    let base_instructions = sess.get_base_instructions().await;
+    let base_instructions = crate::compact_remote::compose_remote_compaction_instructions(
+        sess.get_base_instructions().await,
+        turn_context.config.compact_prompt.as_deref(),
+    );

I also checked the same behavior on 0.150.0 (rust-v0.150.0, commit 3b3b4f8fb3f6403e72c2d0533ed0d2f309c59717).

A useful regression set would cover:

• manual remote V1 with compact_prompt
• automatic remote V1 with compact_prompt
• manual remote V2 with compact_prompt
• automatic remote V2 with compact_prompt
• unset compact_prompt, verifying serialized instructions remain exactly unchanged

It would be great if compact_prompt / experimental_compact_prompt_file could be applied consistently by the official remote-compaction paths so downstream users do not need to carry this source-level difference.