fix: route remote compaction through Responses v2 by default

codex-rs/app-server/tests/suite/v2/compaction.rs

@@ -29,6 +29,7 @@ use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::UserInput as V2UserInput;
 use codex_config::types::AuthCredentialsStoreMode;
+use codex_features::Feature;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
 use core_test_support::responses;
@@ -75,7 +76,7 @@ async fn auto_compaction_local_emits_started_and_completed_items() -> Result<()>
     write_mock_responses_config_toml(
         codex_home.path(),
         &server.uri(),
-        &BTreeMap::default(),
+        &BTreeMap::from([(Feature::RemoteCompactionV2, false)]),
         AUTO_COMPACT_LIMIT,
         /*requires_openai_auth*/ None,
         "mock_provider",
@@ -150,7 +151,7 @@ async fn auto_compaction_remote_emits_started_and_completed_items() -> Result<()
     write_mock_responses_config_toml(
         codex_home.path(),
         &server.uri(),
-        &BTreeMap::default(),
+        &BTreeMap::from([(Feature::RemoteCompactionV2, false)]),
         REMOTE_AUTO_COMPACT_LIMIT,
         Some(true),
         "mock_provider",

codex-rs/core/tests/compact_remote_budget.rs

@@ -637,7 +637,10 @@ async fn v1_transport_and_overflow_retries_share_request_budget() -> Result<()>
     let harness = TestCodexHarness::with_builder(
         test_codex()
             .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
-            .with_config(|config| config.model_provider.request_max_retries = Some(2)),
+            .with_config(|config| {
+                config.model_provider.request_max_retries = Some(2);
+                let _ = config.features.disable(Feature::RemoteCompactionV2);
+            }),
     )
     .await?;
     let codex = harness.test().codex.clone();
@@ -699,7 +702,10 @@ async fn v1_transport_and_overflow_failure_preserves_history() -> Result<()> {
     let harness = TestCodexHarness::with_builder(
         test_codex()
             .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
-            .with_config(|config| config.model_provider.request_max_retries = Some(2)),
+            .with_config(|config| {
+                config.model_provider.request_max_retries = Some(2);
+                let _ = config.features.disable(Feature::RemoteCompactionV2);
+            }),
     )
     .await?;
     let codex = harness.test().codex.clone();

codex-rs/core/tests/suite/auth_profile_auto_switch.rs

@@ -4,6 +4,7 @@ use codex_app_server_protocol::AuthMode;
 use codex_config::types::AuthCredentialsStoreMode;
 use codex_core::compact::SUMMARY_PREFIX;
 use codex_core::config::AuthProfileAutoSwitchStrategy;
+use codex_features::Feature;
 use codex_login::AuthDotJson;
 use codex_login::CodexAuth;
 use codex_protocol::protocol::EventMsg;
@@ -270,6 +271,7 @@ async fn auth_profile_auto_switch_retries_pre_turn_compaction_after_account_exha
         .with_auth(CodexAuth::from_api_key("test-key-root"))
         .with_config(|config| {
             config.model_auto_compact_token_limit = Some(200);
+            let _ = config.features.disable(Feature::RemoteCompactionV2);
             config.selected_auth_profile = Some("account001".to_string());
             config.auth_profile_auto_switch.enabled = true;
             config.auth_profile_auto_switch.strategy = AuthProfileAutoSwitchStrategy::Ordered;

codex-rs/core/tests/suite/client.rs

@@ -2997,6 +2997,7 @@ async fn context_window_error_sets_total_tokens_to_model_window() -> anyhow::Res
         .with_config(|config| {
             config.model = Some("gpt-5.4".to_string());
             config.model_context_window = Some(272_000);
+            let _ = config.features.disable(Feature::RemoteCompactionV2);
         })
         .build(&server)
         .await?;

codex-rs/core/tests/suite/compact.rs

@@ -1496,6 +1496,7 @@ async fn auto_compact_runs_after_resume_when_token_usage_is_over_limit() {
     let mut builder = test_codex().with_config(move |config| {
         set_test_compact_prompt(config);
         config.model_auto_compact_token_limit = Some(limit);
+        let _ = config.features.disable(Feature::RemoteCompactionV2);
     });
     let initial = builder.build(&server).await.unwrap();
     let home = initial.home.clone();
@@ -1524,6 +1525,7 @@ async fn auto_compact_runs_after_resume_when_token_usage_is_over_limit() {
     let mut resume_builder = test_codex().with_config(move |config| {
         set_test_compact_prompt(config);
         config.model_auto_compact_token_limit = Some(limit);
+        let _ = config.features.disable(Feature::RemoteCompactionV2);
     });
     let resumed = resume_builder
         .resume(&server, home, rollout_path)
@@ -3157,6 +3159,7 @@ async fn auto_compact_counts_encrypted_reasoning_before_last_user() {
             config.chatgpt_base_url = chatgpt_base_url;
             set_test_compact_prompt(config);
             config.model_auto_compact_token_limit = Some(300);
+            let _ = config.features.disable(Feature::RemoteCompactionV2);
         })
         .build(&server)
         .await
@@ -3280,6 +3283,7 @@ async fn auto_compact_runs_when_reasoning_header_clears_between_turns() {
         .with_config(|config| {
             set_test_compact_prompt(config);
             config.model_auto_compact_token_limit = Some(300);
+            let _ = config.features.disable(Feature::RemoteCompactionV2);
         })
         .build(&server)
         .await

codex-rs/core/tests/suite/compact_remote.rs

@@ -36,7 +36,7 @@ use core_test_support::responses::start_websocket_server;
 use core_test_support::skip_if_no_network;
 use core_test_support::test_codex::TestCodexBuilder;
 use core_test_support::test_codex::TestCodexHarness;
-use core_test_support::test_codex::test_codex;
+use core_test_support::test_codex::test_codex as base_test_codex;
 use core_test_support::test_path_buf;
 use core_test_support::wait_for_event;
 use core_test_support::wait_for_event_match;
@@ -161,6 +161,12 @@ fn compacted_summary_only_output(summary: &str) -> Vec<ResponseItem> {
     }]
 }
 
+fn test_codex() -> TestCodexBuilder {
+    base_test_codex().with_config(|config| {
+        let _ = config.features.disable(Feature::RemoteCompactionV2);
+    })
+}
+
 fn long_injected_history(item_count: usize) -> Vec<ResponseItem> {
     (0..item_count)
         .map(|index| ResponseItem::Message {

codex-rs/core/tests/suite/compact_remote_parity.rs

@@ -539,8 +539,8 @@ async fn build_harness_inner(
         if hooks {
             trust_discovered_hooks(config);
         }
-        if mode == Mode::V2 {
-            let _ = config.features.enable(Feature::RemoteCompactionV2);
+        if mode == Mode::Legacy {
+            let _ = config.features.disable(Feature::RemoteCompactionV2);
         }
     }))
     .await

codex-rs/core/tests/suite/hooks.rs

@@ -34,7 +34,6 @@ use core_test_support::responses::ev_function_call;
 use core_test_support::responses::ev_message_item_added;
 use core_test_support::responses::ev_output_text_delta;
 use core_test_support::responses::ev_response_created;
-use core_test_support::responses::mount_compact_json_once;
 use core_test_support::responses::mount_sse_once;
 use core_test_support::responses::mount_sse_sequence;
 use core_test_support::responses::sse;
@@ -1441,21 +1440,32 @@ async fn resumed_thread_runs_resume_then_compact_session_start_hooks() -> Result
     let remote_summary = "remote compact summary";
     let resume_context = "remember the resumed reef";
     let compact_context = "remember the compacted reef";
-    let compacted_history = vec![
-        ResponseItem::Message {
-            id: None,
-            role: "assistant".to_string(),
-            content: vec![ContentItem::OutputText {
-                text: remote_summary.to_string(),
-            }],
-            phase: None,
-        },
-        ResponseItem::Compaction {
-            encrypted_content: "encrypted compact summary".to_string(),
-        },
-    ];
-    let compact_mock =
-        mount_compact_json_once(&server, serde_json::json!({ "output": compacted_history })).await;
+    let responses_mock = mount_sse_sequence(
+        &server,
+        vec![
+            sse(vec![
+                ev_response_created("resp-1"),
+                ev_assistant_message("msg-1", "hello before resume"),
+                ev_completed_with_tokens("resp-1", over_limit_tokens),
+            ]),
+            sse(vec![
+                serde_json::json!({
+                    "type": "response.output_item.done",
+                    "item": {
+                        "type": "compaction",
+                        "encrypted_content": remote_summary,
+                    }
+                }),
+                ev_completed("resp-compact"),
+            ]),
+            sse(vec![
+                ev_response_created("resp-2"),
+                ev_assistant_message("msg-2", "hello after resume"),
+                ev_completed("resp-2"),
+            ]),
+        ],
+    )
+    .await;
 
     let mut builder = test_codex()
         .with_pre_build_hook(move |home| {
@@ -1479,37 +1489,19 @@ async fn resumed_thread_runs_resume_then_compact_session_start_hooks() -> Result
         .clone()
         .context("rollout path")?;
 
-    mount_sse_once(
-        &server,
-        sse(vec![
-            ev_response_created("resp-1"),
-            ev_assistant_message("msg-1", "hello before resume"),
-            ev_completed_with_tokens("resp-1", over_limit_tokens),
-        ]),
-    )
-    .await;
     initial.submit_turn("hello before resume").await?;
-    assert!(compact_mock.requests().is_empty());
+    assert_eq!(responses_mock.requests().len(), 1);
 
     let mut resume_builder = test_codex().with_config(move |config| {
         config.model_auto_compact_token_limit = Some(limit);
         trust_discovered_hooks(config);
     });
     let resumed = resume_builder.resume(&server, home, rollout_path).await?;
-    let follow_up = mount_sse_once(
-        &server,
-        sse(vec![
-            ev_response_created("resp-2"),
-            ev_assistant_message("msg-2", "hello after resume"),
-            ev_completed("resp-2"),
-        ]),
-    )
-    .await;
-
     resumed.submit_turn("hello after resume").await?;
 
-    assert_eq!(compact_mock.requests().len(), 1);
-    let developer_messages = follow_up.single_request().message_input_texts("developer");
+    let requests = responses_mock.requests();
+    assert_eq!(requests.len(), 3);
+    let developer_messages = requests[2].message_input_texts("developer");
     assert!(
         developer_messages
             .iter()

codex-rs/core/tests/suite/responses_lite.rs

@@ -283,10 +283,14 @@ async fn responses_lite_compact_request_uses_lite_transport_contract() -> Result
     let compact_mock =
         responses::mount_compact_json_once(&server, serde_json::json!({ "output": [] })).await;
 
-    let mut builder = test_codex().with_model_info_override("gpt-5.4", |model_info| {
-        model_info.use_responses_lite = true;
-        model_info.supports_parallel_tool_calls = true;
-    });
+    let mut builder = test_codex()
+        .with_model_info_override("gpt-5.4", |model_info| {
+            model_info.use_responses_lite = true;
+            model_info.supports_parallel_tool_calls = true;
+        })
+        .with_config(|config| {
+            let _ = config.features.disable(Feature::RemoteCompactionV2);
+        });
     let test = builder.build(&server).await?;
 
     test.submit_turn("Compact this conversation").await?;

codex-rs/features/src/lib.rs

@@ -1284,8 +1284,8 @@ pub const FEATURES: &[FeatureSpec] = &[
     FeatureSpec {
         id: Feature::RemoteCompactionV2,
         key: "remote_compaction_v2",
-        stage: Stage::UnderDevelopment,
-        default_enabled: false,
+        stage: Stage::Stable,
+        default_enabled: true,
     },
     FeatureSpec {
         id: Feature::WorkspaceDependencies,

codex-rs/features/src/tests.rs

@@ -198,9 +198,9 @@ fn request_permissions_tool_is_under_development() {
 }
 
 #[test]
-fn remote_compaction_v2_is_under_development() {
-    assert_eq!(Feature::RemoteCompactionV2.stage(), Stage::UnderDevelopment);
-    assert_eq!(Feature::RemoteCompactionV2.default_enabled(), false);
+fn remote_compaction_v2_is_stable_and_enabled_by_default() {
+    assert_eq!(Feature::RemoteCompactionV2.stage(), Stage::Stable);
+    assert_eq!(Feature::RemoteCompactionV2.default_enabled(), true);
     assert_eq!(
         feature_for_key("remote_compaction_v2"),
         Some(Feature::RemoteCompactionV2)