Drop compaction started/ended notifications

codex-rs/app-server-protocol/src/protocol/common.rs

@@ -598,6 +598,7 @@ server_notification_definitions! {
     ReasoningSummaryTextDelta => "item/reasoning/summaryTextDelta" (v2::ReasoningSummaryTextDeltaNotification),
     ReasoningSummaryPartAdded => "item/reasoning/summaryPartAdded" (v2::ReasoningSummaryPartAddedNotification),
     ReasoningTextDelta => "item/reasoning/textDelta" (v2::ReasoningTextDeltaNotification),
+    /// Deprecated: use the compaction item lifecycle.
     ContextCompacted => "thread/compacted" (v2::ContextCompactedNotification),
     DeprecationNotice => "deprecationNotice" (v2::DeprecationNoticeNotification),
     ConfigWarning => "configWarning" (v2::ConfigWarningNotification),

codex-rs/app-server-protocol/src/protocol/v2.rs

@@ -1962,6 +1962,9 @@ pub enum ThreadItem {
     WebSearch { id: String, query: String },
     #[serde(rename_all = "camelCase")]
     #[ts(rename_all = "camelCase")]
+    Compaction { id: String },
+    #[serde(rename_all = "camelCase")]
+    #[ts(rename_all = "camelCase")]
     ImageView { id: String, path: String },
     #[serde(rename_all = "camelCase")]
     #[ts(rename_all = "camelCase")]
@@ -2359,6 +2362,7 @@ pub struct WindowsWorldWritableWarningNotification {
     pub failed_scan: bool,
 }
 
+/// Deprecated: use the compaction item lifecycle.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]

codex-rs/app-server/README.md

@@ -431,7 +431,8 @@ Today both notifications carry an empty `items` array even when item events were
 - `imageView` — `{id, path}` emitted when the agent invokes the image viewer tool.
 - `enteredReviewMode` — `{id, review}` sent when the reviewer starts; `review` is a short user-facing label such as `"current changes"` or the requested target description.
 - `exitedReviewMode` — `{id, review}` emitted when the reviewer finishes; `review` is the full plain-text review (usually, overall notes plus bullet point findings).
-- `compacted` - `{threadId, turnId}` when codex compacts the conversation history. This can happen automatically.
+- `compaction` — `{id}` emitted via `item/started` and `item/completed` when Codex compacts conversation history for the current turn.
+- `thread/compacted` is deprecated and should be treated as the compaction completion signal.
 
 All items emit two shared lifecycle events:
 

codex-rs/app-server/src/bespoke_event_handling.rs

@@ -601,13 +601,33 @@ pub(crate) async fn apply_bespoke_event_handling(
                 .send_server_notification(ServerNotification::AgentMessageDelta(notification))
                 .await;
         }
-        EventMsg::ContextCompacted(..) => {
-            let notification = ContextCompactedNotification {
+        EventMsg::CompactionStarted(..) => {
+            let item = compaction_item(&event_turn_id);
+            let notification = ItemStartedNotification {
+                thread_id: conversation_id.to_string(),
+                turn_id: event_turn_id.clone(),
+                item,
+            };
+            outgoing
+                .send_server_notification(ServerNotification::ItemStarted(notification))
+                .await;
+        }
+        EventMsg::CompactionEnded(..) => {
+            let item = compaction_item(&event_turn_id);
+            let completed = ItemCompletedNotification {
+                thread_id: conversation_id.to_string(),
+                turn_id: event_turn_id.clone(),
+                item,
+            };
+            outgoing
+                .send_server_notification(ServerNotification::ItemCompleted(completed))
+                .await;
+            let legacy = ContextCompactedNotification {
                 thread_id: conversation_id.to_string(),
                 turn_id: event_turn_id.clone(),
             };
             outgoing
-                .send_server_notification(ServerNotification::ContextCompacted(notification))
+                .send_server_notification(ServerNotification::ContextCompacted(legacy))
                 .await;
         }
         EventMsg::DeprecationNotice(event) => {
@@ -1270,6 +1290,12 @@ async fn maybe_emit_raw_response_item_completed(
         .await;
 }
 
+fn compaction_item(turn_id: &str) -> ThreadItem {
+    ThreadItem::Compaction {
+        id: format!("{turn_id}-compaction"),
+    }
+}
+
 async fn find_and_remove_turn_summary(
     conversation_id: ThreadId,
     turn_summary_store: &TurnSummaryStore,

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

@@ -0,0 +1,243 @@
+use anyhow::Result;
+use app_test_support::McpProcess;
+use app_test_support::to_response;
+use codex_app_server_protocol::ClientInfo;
+use codex_app_server_protocol::ContextCompactedNotification;
+use codex_app_server_protocol::ItemCompletedNotification;
+use codex_app_server_protocol::ItemStartedNotification;
+use codex_app_server_protocol::JSONRPCNotification;
+use codex_app_server_protocol::JSONRPCResponse;
+use codex_app_server_protocol::RequestId;
+use codex_app_server_protocol::ThreadItem;
+use codex_app_server_protocol::ThreadStartParams;
+use codex_app_server_protocol::ThreadStartResponse;
+use codex_app_server_protocol::TurnStartParams;
+use codex_app_server_protocol::TurnStartResponse;
+use codex_app_server_protocol::UserInput as V2UserInput;
+use codex_core::features::FEATURES;
+use codex_core::features::Feature;
+use core_test_support::responses;
+use core_test_support::skip_if_no_network;
+use pretty_assertions::assert_eq;
+use std::collections::BTreeMap;
+use std::path::Path;
+use tempfile::TempDir;
+use tokio::time::timeout;
+use wiremock::MockServer;
+
+const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
+const TEST_ORIGINATOR: &str = "codex_vscode";
+
+#[tokio::test]
+async fn compaction_emits_item_lifecycle_and_legacy_completion_notification() -> Result<()> {
+    skip_if_no_network!(Ok(()));
+
+    let server = responses::start_mock_server().await;
+    mount_compaction_flow(&server).await;
+
+    let codex_home = TempDir::new()?;
+    create_compaction_config_toml(codex_home.path(), &server.uri())?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.initialize_with_client_info(ClientInfo {
+            name: TEST_ORIGINATOR.to_string(),
+            title: Some("Codex VS Code Extension".to_string()),
+            version: "0.1.0".to_string(),
+        }),
+    )
+    .await??;
+
+    let thread_req = mcp
+        .send_thread_start_request(ThreadStartParams {
+            model: Some("mock-model".to_string()),
+            ..Default::default()
+        })
+        .await?;
+    let thread_resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
+    )
+    .await??;
+    let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
+
+    let turn_req = mcp
+        .send_turn_start_request(TurnStartParams {
+            thread_id: thread.id.clone(),
+            input: vec![V2UserInput::Text {
+                text: "trigger compaction".to_string(),
+                text_elements: Vec::new(),
+            }],
+            ..Default::default()
+        })
+        .await?;
+    let turn_resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
+    )
+    .await??;
+    let TurnStartResponse { turn, .. } = to_response::<TurnStartResponse>(turn_resp)?;
+    let turn_id = turn.id;
+
+    let compaction_started =
+        timeout(DEFAULT_READ_TIMEOUT, read_compaction_item_started(&mut mcp)).await??;
+    let compaction_completed = timeout(
+        DEFAULT_READ_TIMEOUT,
+        read_compaction_item_completed(&mut mcp),
+    )
+    .await??;
+    let legacy_completed = timeout(
+        DEFAULT_READ_TIMEOUT,
+        read_legacy_compacted_notification(&mut mcp),
+    )
+    .await??;
+
+    let compaction_id = format!("{turn_id}-compaction");
+    let expected_started = ItemStartedNotification {
+        thread_id: thread.id.clone(),
+        turn_id: turn_id.clone(),
+        item: ThreadItem::Compaction {
+            id: compaction_id.clone(),
+        },
+    };
+    let expected_completed = ItemCompletedNotification {
+        thread_id: thread.id.clone(),
+        turn_id: turn_id.clone(),
+        item: ThreadItem::Compaction { id: compaction_id },
+    };
+    let expected_legacy = ContextCompactedNotification {
+        thread_id: thread.id.clone(),
+        turn_id,
+    };
+
+    assert_eq!(compaction_started, expected_started);
+    assert_eq!(compaction_completed, expected_completed);
+    assert_eq!(legacy_completed, expected_legacy);
+
+    Ok(())
+}
+
+async fn read_compaction_item_started(mcp: &mut McpProcess) -> Result<ItemStartedNotification> {
+    loop {
+        let notification = mcp
+            .read_stream_until_notification_message("item/started")
+            .await?;
+        let params = notification.params.expect("item/started params");
+        let started: ItemStartedNotification = serde_json::from_value(params)?;
+        if matches!(started.item, ThreadItem::Compaction { .. }) {
+            return Ok(started);
+        }
+    }
+}
+
+async fn read_compaction_item_completed(mcp: &mut McpProcess) -> Result<ItemCompletedNotification> {
+    loop {
+        let notification = mcp
+            .read_stream_until_notification_message("item/completed")
+            .await?;
+        let params = notification.params.expect("item/completed params");
+        let completed: ItemCompletedNotification = serde_json::from_value(params)?;
+        if matches!(completed.item, ThreadItem::Compaction { .. }) {
+            return Ok(completed);
+        }
+    }
+}
+
+async fn read_legacy_compacted_notification(
+    mcp: &mut McpProcess,
+) -> Result<ContextCompactedNotification> {
+    let notification: JSONRPCNotification = mcp
+        .read_stream_until_notification_message("thread/compacted")
+        .await?;
+    let params = notification.params.expect("thread/compacted params");
+    let legacy: ContextCompactedNotification = serde_json::from_value(params)?;
+    Ok(legacy)
+}
+
+async fn mount_compaction_flow(server: &MockServer) {
+    responses::mount_sse_once(
+        server,
+        responses::sse(vec![
+            responses::ev_response_created("resp-1"),
+            responses::ev_shell_command_call("call-1", "echo hi"),
+            responses::ev_completed_with_tokens("resp-1", 1_000_000),
+        ]),
+    )
+    .await;
+
+    responses::mount_sse_once(
+        server,
+        responses::sse(vec![
+            responses::ev_response_created("resp-2"),
+            responses::ev_assistant_message("msg-2", "post-compact"),
+            responses::ev_completed("resp-2"),
+        ]),
+    )
+    .await;
+
+    let compacted_history = serde_json::json!([
+        {
+            "type": "message",
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": "COMPACTED_SUMMARY"
+                }
+            ]
+        },
+        {
+            "type": "compaction",
+            "encrypted_content": "ENCRYPTED_COMPACTION_SUMMARY"
+        }
+    ]);
+    responses::mount_compact_json_once(server, serde_json::json!({ "output": compacted_history }))
+        .await;
+}
+
+fn create_compaction_config_toml(codex_home: &Path, server_uri: &str) -> std::io::Result<()> {
+    let feature_flags = BTreeMap::from([(Feature::RemoteCompaction, true)]);
+    let mut features = BTreeMap::from([(Feature::RemoteModels, false)]);
+    for (feature, enabled) in feature_flags {
+        features.insert(feature, enabled);
+    }
+
+    let feature_entries = features
+        .into_iter()
+        .map(|(feature, enabled)| {
+            let key = FEATURES
+                .iter()
+                .find(|spec| spec.id == feature)
+                .map(|spec| spec.key)
+                .unwrap_or_else(|| panic!("missing feature key for {feature:?}"));
+            format!("{key} = {enabled}")
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    let config_toml = codex_home.join("config.toml");
+    std::fs::write(
+        config_toml,
+        format!(
+            r#"
+model = "mock-model"
+approval_policy = "never"
+sandbox_mode = "read-only"
+model_provider = "mock_provider"
+model_auto_compact_token_limit = 1
+compact_prompt = "Summarize the conversation."
+
+[features]
+{feature_entries}
+
+[model_providers.mock_provider]
+name = "Mock provider for test"
+base_url = "{server_uri}/v1"
+wire_api = "responses"
+request_max_retries = 0
+stream_max_retries = 0
+"#
+        ),
+    )
+}

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

@@ -2,6 +2,7 @@ mod account;
 mod analytics;
 mod app_list;
 mod collaboration_mode_list;
+mod compaction;
 mod config_rpc;
 mod dynamic_tools;
 mod initialize;

codex-rs/core/src/compact.rs

@@ -10,7 +10,8 @@ use crate::error::CodexErr;
 use crate::error::Result as CodexResult;
 use crate::features::Feature;
 use crate::protocol::CompactedItem;
-use crate::protocol::ContextCompactedEvent;
+use crate::protocol::CompactionEndedEvent;
+use crate::protocol::CompactionStartedEvent;
 use crate::protocol::EventMsg;
 use crate::protocol::TurnContextItem;
 use crate::protocol::TurnStartedEvent;
@@ -104,6 +105,11 @@ async fn run_compact_task_inner(
         truncation_policy: Some(turn_context.truncation_policy.into()),
     });
     sess.persist_rollout_items(&[rollout_item]).await;
+    sess.send_event(
+        &turn_context,
+        EventMsg::CompactionStarted(CompactionStartedEvent {}),
+    )
+    .await;
 
     loop {
         // Clone is required because of the loop
@@ -193,7 +199,7 @@ async fn run_compact_task_inner(
     });
     sess.persist_rollout_items(&[rollout_item]).await;
 
-    let event = EventMsg::ContextCompacted(ContextCompactedEvent {});
+    let event = EventMsg::CompactionEnded(CompactionEndedEvent {});
     sess.send_event(&turn_context, event).await;
 
     let warning = EventMsg::Warning(WarningEvent {

codex-rs/core/src/compact_remote.rs

@@ -5,7 +5,8 @@ use crate::codex::Session;
 use crate::codex::TurnContext;
 use crate::error::Result as CodexResult;
 use crate::protocol::CompactedItem;
-use crate::protocol::ContextCompactedEvent;
+use crate::protocol::CompactionEndedEvent;
+use crate::protocol::CompactionStartedEvent;
 use crate::protocol::EventMsg;
 use crate::protocol::RolloutItem;
 use crate::protocol::TurnStartedEvent;
@@ -59,6 +60,11 @@ async fn run_remote_compact_task_inner_impl(
         output_schema: None,
     };
 
+    sess.send_event(
+        turn_context,
+        EventMsg::CompactionStarted(CompactionStartedEvent {}),
+    )
+    .await;
     let mut new_history = turn_context
         .client
         .compact_conversation_history(&prompt)
@@ -77,7 +83,7 @@ async fn run_remote_compact_task_inner_impl(
     sess.persist_rollout_items(&[RolloutItem::Compacted(compacted_item)])
         .await;
 
-    let event = EventMsg::ContextCompacted(ContextCompactedEvent {});
+    let event = EventMsg::CompactionEnded(CompactionEndedEvent {});
     sess.send_event(turn_context, event).await;
 
     Ok(())

codex-rs/core/src/rollout/policy.rs

@@ -42,7 +42,8 @@ pub(crate) fn should_persist_event_msg(ev: &EventMsg) -> bool {
         | EventMsg::AgentReasoning(_)
         | EventMsg::AgentReasoningRawContent(_)
         | EventMsg::TokenCount(_)
-        | EventMsg::ContextCompacted(_)
+        | EventMsg::CompactionStarted(_)
+        | EventMsg::CompactionEnded(_)
         | EventMsg::EnteredReviewMode(_)
         | EventMsg::ExitedReviewMode(_)
         | EventMsg::ThreadRolledBack(_)

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

@@ -1277,7 +1277,11 @@ async fn auto_compact_runs_after_resume_when_token_usage_is_over_limit() {
         .unwrap();
 
     wait_for_event(&resumed.codex, |event| {
-        matches!(event, EventMsg::ContextCompacted(_))
+        matches!(event, EventMsg::CompactionStarted(_))
+    })
+    .await;
+    wait_for_event(&resumed.codex, |event| {
+        matches!(event, EventMsg::CompactionEnded(_))
     })
     .await;
     wait_for_event(&resumed.codex, |event| {

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

@@ -201,8 +201,9 @@ async fn remote_compact_runs_automatically() -> Result<()> {
             final_output_json_schema: None,
         })
         .await?;
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::CompactionStarted(_))).await;
     let message = wait_for_event_match(&codex, |ev| match ev {
-        EventMsg::ContextCompacted(_) => Some(true),
+        EventMsg::CompactionEnded(_) => Some(true),
         _ => None,
     })
     .await;

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -590,7 +590,10 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                     ts_msg!(self, "task aborted: review ended");
                 }
             },
-            EventMsg::ContextCompacted(_) => {
+            EventMsg::CompactionStarted(_) => {
+                ts_msg!(self, "compacting context");
+            }
+            EventMsg::CompactionEnded(_) => {
                 ts_msg!(self, "context compacted");
             }
             EventMsg::CollabAgentSpawnBegin(CollabAgentSpawnBeginEvent {

codex-rs/mcp-server/src/codex_tool_runner.rs

@@ -361,7 +361,8 @@ async fn run_codex_tool_session_inner(
                     | EventMsg::ExitedReviewMode(_)
                     | EventMsg::RequestUserInput(_)
                     | EventMsg::DynamicToolCallRequest(_)
-                    | EventMsg::ContextCompacted(_)
+                    | EventMsg::CompactionStarted(_)
+                    | EventMsg::CompactionEnded(_)
                     | EventMsg::ThreadRolledBack(_)
                     | EventMsg::CollabAgentSpawnBegin(_)
                     | EventMsg::CollabAgentSpawnEnd(_)

codex-rs/protocol/src/protocol.rs

@@ -683,8 +683,12 @@ pub enum EventMsg {
     /// indicates the turn continued but the user should still be notified.
     Warning(WarningEvent),
 
-    /// Conversation history was compacted (either automatically or manually).
-    ContextCompacted(ContextCompactedEvent),
+    /// Conversation history compaction has started.
+    CompactionStarted(CompactionStartedEvent),
+
+    /// Conversation history compaction has completed.
+    #[serde(alias = "context_compacted")]
+    CompactionEnded(CompactionEndedEvent),
 
     /// Conversation history was rolled back by dropping the last N user turns.
     ThreadRolledBack(ThreadRolledBackEvent),
@@ -1078,7 +1082,14 @@ pub struct WarningEvent {
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS)]
-pub struct ContextCompactedEvent;
+pub struct CompactionStartedEvent;
+
+#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS)]
+pub struct CompactionEndedEvent;
+
+#[allow(deprecated)]
+#[deprecated(note = "Use CompactionEndedEvent")]
+pub type ContextCompactedEvent = CompactionEndedEvent;
 
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS)]
 pub struct TurnCompleteEvent {

codex-rs/tui/src/chatwidget.rs

@@ -3057,7 +3057,10 @@ impl ChatWidget {
                 self.on_entered_review_mode(review_request, from_replay)
             }
             EventMsg::ExitedReviewMode(review) => self.on_exited_review_mode(review),
-            EventMsg::ContextCompacted(_) => self.on_agent_message("Context compacted".to_owned()),
+            EventMsg::CompactionStarted(_) => {
+                self.on_agent_message("Compacting context...".to_owned())
+            }
+            EventMsg::CompactionEnded(_) => self.on_agent_message("Context compacted".to_owned()),
             EventMsg::CollabAgentSpawnBegin(_) => {}
             EventMsg::CollabAgentSpawnEnd(ev) => self.on_collab_event(collab::spawn_end(ev)),
             EventMsg::CollabAgentInteractionBegin(_) => {}