From e5839cbc591df02408d5009e287887c7d57a9167 Mon Sep 17 00:00:00 2001 From: jif Date: Mon, 16 Nov 2026 14:02:34 +0000 Subject: [PATCH] Preserve aggregate turn diffs across steering (#61820) ## Why A steer can restart sampling within the same turn. Recreating the diff tracker loses earlier edits, and changing the working directory can change the meaning of relative diff paths. ## What changed Keep the diff tracker for the lifetime of the turn and retain each environment's first display root. Refresh cached diff headers when new environments are added. Emit the final aggregate `TurnDiff` before `TurnComplete` instead of at sampling completion. ## Testing Extend regression coverage for steering during the final flush, with and without additional patches and with a changed working directory. Check final diff ordering across continued sampling and header updates when adding an environment. GitOrigin-RevId: fbd1ebef072d8486a324190c9125fc1446510802 --- codex-rs/core/src/session/turn.rs | 31 ++--- codex-rs/core/src/tasks/mod.rs | 16 +++ codex-rs/core/src/turn_diff_tracker.rs | 21 +++- codex-rs/core/src/turn_diff_tracker_tests.rs | 25 ++-- codex-rs/core/tests/suite/apply_patch_cli.rs | 30 +++-- .../tests/suite/pending_input_persistence.rs | 115 ++++++++++++++---- 6 files changed, 164 insertions(+), 74 deletions(-) diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index 02314340c8..0deab079e8 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -119,7 +119,6 @@ use codex_protocol::protocol::ReasoningContentDeltaEvent; use codex_protocol::protocol::ReasoningRawContentDeltaEvent; use codex_protocol::protocol::SafetyBufferingEvent; use codex_protocol::protocol::SessionSource; -use codex_protocol::protocol::TurnDiffEvent; use codex_protocol::protocol::WarningEvent; use codex_protocol::user_input::UserInput; use codex_skills::ToolMentionKind; @@ -523,11 +522,14 @@ pub(crate) async fn run_turn( let mut last_agent_message: Option = None; let mut stop_hook_active = false; - // Although from the perspective of codex.rs, TurnDiffTracker has the lifecycle of a Task which contains - // many turns, from the perspective of the user, it is a single turn. - let turn_diff_tracker = Arc::new(tokio::sync::Mutex::new( - TurnDiffTracker::with_environment_display_roots(display_roots), - )); + // A steer can reopen sampling within the same turn. Keep its aggregate until the turn ends. + let turn_diff_tracker = turn_context + .extension_data + .get_or_init(|| tokio::sync::Mutex::new(TurnDiffTracker::new())); + turn_diff_tracker + .lock() + .await + .update_environment_display_roots(display_roots); // `ModelClientSession` is turn-scoped and caches WebSocket + sticky routing state, so we reuse // one instance across retries within this turn. @@ -1974,7 +1976,7 @@ async fn run_sampling_request( let _code_mode_worker = sess.services.code_mode_service.start_turn_worker( &sess, Arc::clone(&step_context), - Arc::clone(&turn_diff_tracker), + turn_diff_tracker, ); let max_retries = turn_context.provider.info().stream_max_retries(); let incremental_tools = sess @@ -2072,7 +2074,6 @@ async fn run_sampling_request( Arc::clone(&turn_store), client_session, &responses_metadata, - Arc::clone(&turn_diff_tracker), prompt, pending_audio, input_item_count, @@ -2944,7 +2945,6 @@ async fn try_run_sampling_request( turn_store: Arc, client_session: &mut ModelClientSession, responses_metadata: &CodexResponsesMetadata, - turn_diff_tracker: SharedTurnDiffTracker, prompt: Prompt, mut pending_audio: Option, input_item_count: usize, @@ -3063,7 +3063,6 @@ async fn try_run_sampling_request( String, Box, )> = None; - let mut should_emit_turn_diff = false; let mut should_emit_token_count = false; const MAX_ANALYTICS_TOOL_CALL_IDS_PER_RESPONSE: usize = 256; let mut analytics_tool_call_ids = Vec::new(); @@ -3616,7 +3615,6 @@ async fn try_run_sampling_request( ) .await; should_emit_token_count = true; - should_emit_turn_diff = true; if let Err(err) = budget_result { break Err(err); } @@ -3832,17 +3830,6 @@ async fn try_run_sampling_request( return Err(CodexErr::TurnAborted); } - if should_emit_turn_diff { - let unified_diff = { - let tracker = turn_diff_tracker.lock().await; - tracker.get_unified_diff() - }; - if let Some(unified_diff) = unified_diff { - let msg = EventMsg::TurnDiff(TurnDiffEvent { unified_diff }); - sess.clone().send_event(&turn_context, msg).await; - } - } - outcome } diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index a00369c736..9debf1956e 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -42,6 +42,7 @@ use crate::state::ActiveTurn; use crate::state::RunningTask; use crate::state::TaskKind; use crate::state::TurnState; +use crate::turn_diff_tracker::TurnDiffTracker; use codex_analytics::TurnProfileFact; use codex_analytics::TurnTokenUsageFact; use codex_context_fragments::RenderedFragment; @@ -61,6 +62,7 @@ use codex_protocol::protocol::TokenUsage; use codex_protocol::protocol::TurnAbortReason; use codex_protocol::protocol::TurnAbortedEvent; use codex_protocol::protocol::TurnCompleteEvent; +use codex_protocol::protocol::TurnDiffEvent; use codex_protocol::protocol::WarningEvent; use codex_protocol::turn_input::NotSubmittedReason; use codex_protocol::turn_input::TurnInputSubmission; @@ -1015,6 +1017,7 @@ impl Session { }; let saved_guardian_completion = matches!(event, EventMsg::TurnComplete(_)) && self.is_private_guardian_reviewer().await; + self.finish_turn_diff(&turn_context, &event).await; if !saved_guardian_completion { self.send_event(turn_context.as_ref(), event.clone()).await; } @@ -1050,6 +1053,18 @@ impl Session { None } + async fn finish_turn_diff(&self, turn: &TurnContext, terminal_event: &EventMsg) { + let tracker = turn.extension_data.remove::>(); + let (EventMsg::TurnComplete(_), Some(tracker)) = (terminal_event, tracker) else { + return; + }; + let unified_diff = tracker.lock().await.get_unified_diff(); + if let Some(unified_diff) = unified_diff { + self.send_event(turn, EventMsg::TurnDiff(TurnDiffEvent { unified_diff })) + .await; + } + } + async fn take_active_turn(&self, reason: &TurnAbortReason) -> Option { let mut active = self.active_turn.lock().await; if matches!( @@ -1223,6 +1238,7 @@ impl Session { completed_at, duration_ms, }); + self.finish_turn_diff(&task.turn_context, &event).await; self.send_event(task.turn_context.as_ref(), event).await; // Regular items were flushed before this terminal event was appended; buffering // thread writers may not flush it without another explicit barrier. diff --git a/codex-rs/core/src/turn_diff_tracker.rs b/codex-rs/core/src/turn_diff_tracker.rs index 06a2cd022e..9db4d66b83 100644 --- a/codex-rs/core/src/turn_diff_tracker.rs +++ b/codex-rs/core/src/turn_diff_tracker.rs @@ -81,12 +81,23 @@ impl TurnDiffTracker { Self::default() } - pub fn with_environment_display_roots( + /// Use each environment's first display root for the whole turn so a steer cannot + /// change what an already published relative path refers to. + pub(crate) fn update_environment_display_roots( + &mut self, display_roots: impl IntoIterator, - ) -> Self { - let mut tracker = Self::new(); - tracker.display_roots_by_environment = display_roots.into_iter().collect(); - tracker + ) { + let previous_environment_count = self.display_roots_by_environment.len(); + for (id, root) in display_roots { + self.display_roots_by_environment.entry(id).or_insert(root); + } + if self.display_roots_by_environment.len() != previous_environment_count + && !self.rendered_diffs.is_empty() + { + // Adding an environment can add an environment ID prefix to existing headers. + self.rendered_diffs.clear(); + self.refresh_unified_diff(); + } } pub fn track_delta(&mut self, environment_id: &str, delta: &AppliedPatchDelta) { diff --git a/codex-rs/core/src/turn_diff_tracker_tests.rs b/codex-rs/core/src/turn_diff_tracker_tests.rs index 27af3ff32b..46da03b0bb 100644 --- a/codex-rs/core/src/turn_diff_tracker_tests.rs +++ b/codex-rs/core/src/turn_diff_tracker_tests.rs @@ -47,10 +47,12 @@ async fn apply_verified_patch(root: &Path, patch: &str) -> AppliedPatchDelta { } fn tracker_with_root(root: &Path) -> TurnDiffTracker { - TurnDiffTracker::with_environment_display_roots([( + let mut tracker = TurnDiffTracker::new(); + tracker.update_environment_display_roots([( "".to_string(), PathUri::from_host_native_path(root).expect("absolute display root"), - )]) + )]); + tracker } #[tokio::test] @@ -113,18 +115,12 @@ async fn tracks_same_absolute_path_across_multiple_environments() { ) .await; - let mut tracker = TurnDiffTracker::with_environment_display_roots([ - ( - "local".to_string(), - PathUri::from_host_native_path(dir.path()).expect("absolute local display root"), - ), - ( - "remote".to_string(), - PathUri::from_host_native_path(dir.path()).expect("absolute remote display root"), - ), - ]); - tracker.track_delta("remote", &add); + let mut tracker = TurnDiffTracker::new(); + let root = PathUri::from_host_native_path(dir.path()).expect("absolute display root"); + tracker.update_environment_display_roots([("local".to_string(), root.clone())]); tracker.track_delta("local", &add); + tracker.update_environment_display_roots([("remote".to_string(), root)]); + tracker.track_delta("remote", &add); let right_oid = git_blob_sha1_hex("content\n"); let expected = format!( @@ -149,7 +145,8 @@ index {ZERO_OID}..{right_oid} #[test] fn displays_foreign_paths_relative_to_their_environment_root() { - let tracker = TurnDiffTracker::with_environment_display_roots([( + let mut tracker = TurnDiffTracker::new(); + tracker.update_environment_display_roots([( "windows".to_string(), PathUri::parse("file:///C:/workspace/project").expect("valid Windows display root"), )]); diff --git a/codex-rs/core/tests/suite/apply_patch_cli.rs b/codex-rs/core/tests/suite/apply_patch_cli.rs index 3681a7ed22..ebdc8c90b5 100644 --- a/codex-rs/core/tests/suite/apply_patch_cli.rs +++ b/codex-rs/core/tests/suite/apply_patch_cli.rs @@ -2455,26 +2455,34 @@ async fn apply_patch_aggregates_diff_across_multiple_tool_calls() -> Result<()> ev_apply_patch_custom_tool_call(call2, patch2), ev_completed("resp-2"), ]); - let s3 = sse(vec![ + let mut continue_sampling = ev_completed("resp-3"); + continue_sampling["response"]["end_turn"] = json!(false); + let s3 = sse(vec![ev_response_created("resp-3"), continue_sampling]); + let s4 = sse(vec![ ev_assistant_message("msg-1", "ok"), - ev_completed("resp-3"), + ev_completed("resp-4"), ]); - mount_sse_sequence(harness.server(), vec![s1, s2, s3]).await; + mount_sse_sequence(harness.server(), vec![s1, s2, s3, s4]).await; submit_without_wait(&harness, "aggregate diffs").await?; - let mut last_diff: Option = None; - wait_for_event(&codex, |event| match event { - EventMsg::TurnDiff(ev) => { - last_diff = Some(ev.unified_diff.clone()); - false + let mut saw_final_answer = false; + let mut diffs = Vec::new(); + wait_for_event(&codex, |event| { + match event { + EventMsg::TurnDiff(ev) => diffs.push((saw_final_answer, ev.unified_diff.clone())), + EventMsg::AgentMessage(message) if message.message == "ok" => saw_final_answer = true, + _ => {} } - EventMsg::TurnComplete(_) => true, - _ => false, + matches!(event, EventMsg::TurnComplete(_)) }) .await; - let diff = last_diff.expect("expected TurnDiff after two patches"); + let [(false, first), (false, diff), (true, final_diff)] = diffs.as_slice() else { + anyhow::bail!("expected both patch updates and one final snapshot, got {diffs:?}"); + }; + assert!(first.contains("+v1\n")); + assert_eq!(final_diff, diff); assert!(diff.contains("agg/a.txt"), "diff missing agg/a.txt: {diff}"); assert!(diff.contains("agg/b.txt"), "diff missing agg/b.txt: {diff}"); // Final content reflects v2 for a.txt diff --git a/codex-rs/core/tests/suite/pending_input_persistence.rs b/codex-rs/core/tests/suite/pending_input_persistence.rs index 6312e5342a..277f32cce2 100644 --- a/codex-rs/core/tests/suite/pending_input_persistence.rs +++ b/codex-rs/core/tests/suite/pending_input_persistence.rs @@ -16,10 +16,15 @@ use codex_protocol::AgentPath; use codex_protocol::ThreadId; use codex_protocol::mcp::ClientMcpExtensions; use codex_protocol::models::ResponseItem; +use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::EventMsg; use codex_protocol::protocol::InterAgentCommunication; use codex_protocol::protocol::Op; +use codex_protocol::protocol::SandboxPolicy; use codex_protocol::protocol::ThreadHistoryMode; +use codex_protocol::protocol::ThreadSettingsOverrides; +use codex_protocol::protocol::TurnSettingsUpdate; +use codex_protocol::protocol::TurnSettingsUpdateOutcome; use codex_protocol::user_input::UserInput; use codex_rollout::RolloutItem; use codex_rollout::RolloutRecorder; @@ -363,26 +368,43 @@ async fn steered_input_checkpoint_controls_next_request( Ok(()) } +#[test_case(false; "read_only_steer")] +#[test_case(true; "steer_with_patch")] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> anyhow::Result<()> { +async fn steer_during_final_flush_reaches_the_model_before_turn_completion( + patch_after_steer: bool, +) -> anyhow::Result<()> { let server = responses::start_mock_server().await; - let responses = responses::mount_sse_sequence( - &server, - [ - ("first", "original answer"), - ("second", "answer to the steer"), - ] - .into_iter() - .map(|(id, answer)| { - responses::sse(vec![ - responses::ev_response_created(id), - responses::ev_assistant_message(id, answer), - responses::ev_completed(id), - ]) - }) - .collect(), - ) - .await; + let patch_response = |id, patch| { + responses::sse(vec![ + responses::ev_response_created(id), + responses::ev_apply_patch_custom_tool_call(id, patch), + responses::ev_completed(id), + ]) + }; + let answer_response = |id, answer| { + responses::sse(vec![ + responses::ev_response_created(id), + responses::ev_assistant_message(id, answer), + responses::ev_completed(id), + ]) + }; + let mut sequence = vec![ + patch_response( + "patch-first", + "*** Begin Patch\n*** Add File: before.txt\n+root\n*** Add File: nested/before.txt\n+nested\n*** End Patch", + ), + answer_response("first", "original answer"), + ]; + if patch_after_steer { + sequence.push(patch_response( + "patch-second", + "*** Begin Patch\n*** Add File: later.txt\n+ok\n*** End Patch", + )); + } + sequence.push(answer_response("second", "answer to the steer")); + let expected_requests = sequence.len(); + let responses = responses::mount_sse_sequence(&server, sequence).await; let (checkpoints, _checkpoint_requests) = mpsc::unbounded_channel(); let store = Arc::new(GatedCheckpointStore { inner: InMemoryThreadStore::default(), @@ -394,6 +416,12 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> next_flush: Mutex::default(), }); let test = test_codex() + .with_config(|config| { + config + .features + .enable(Feature::CwdRelativeTurnDiffs) + .expect("enable cwd-relative turn diffs"); + }) .with_thread_store(store.clone()) .with_history_mode(ThreadHistoryMode::Legacy) .build_with_auto_env(&server) @@ -414,7 +442,13 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> root_turn_id, } = test .codex - .start_or_steer_turn(user_message("first prompt", None)) + .start_or_steer_turn(user_message("first prompt", None).with_thread_settings( + ThreadSettingsOverrides { + approval_policy: Some(AskForApproval::Never), + sandbox_policy: Some(SandboxPolicy::DangerFullAccess), + ..Default::default() + }, + )) .await? else { panic!("expected a new turn"); @@ -422,7 +456,22 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> // The regular task returned its first answer and is flushing before it completes the turn. timeout(Duration::from_secs(10), flush.wait()).await?; - assert_eq!(responses.requests().len(), 1); + assert_eq!(responses.requests().len(), 2); + let mut environment = test.executor_environment().request(); + environment.cwd = environment.cwd.join("nested")?; + environment.workspace_roots = vec![environment.cwd.clone()]; + let (reply, outcome) = oneshot::channel(); + test.codex + .submit(Op::TurnSettings { + turn_id: turn_id.clone(), + update: TurnSettingsUpdate { + environments: Some(vec![environment]), + ..Default::default() + }, + reply, + }) + .await?; + assert_eq!(outcome.await?, TurnSettingsUpdateOutcome::Applied); let steer = timeout( Duration::from_secs(10), test.codex @@ -438,11 +487,19 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> } ); + let mut saw_steered_answer = false; + let mut final_diff = String::new(); let mut starts = 0; let mut client_ids = Vec::new(); let EventMsg::TurnComplete(completed) = wait_for_event(&test.codex, |event| { match event { EventMsg::TurnStarted(_) => starts += 1, + EventMsg::AgentMessage(message) if message.message == "answer to the steer" => { + saw_steered_answer = true; + } + EventMsg::TurnDiff(event) if saw_steered_answer => { + final_diff.clone_from(&event.unified_diff); + } EventMsg::UserMessage(message) if message.message == "late steer" => { client_ids.push(message.client_id.clone()); } @@ -459,12 +516,26 @@ async fn steer_during_final_flush_reaches_the_model_before_turn_completion() -> completed.last_agent_message.as_deref(), Some("answer to the steer") ); + let mut expected_headers = vec![ + "diff --git a/before.txt b/before.txt", + "diff --git a/nested/before.txt b/nested/before.txt", + ]; + if patch_after_steer { + expected_headers.push("diff --git a/nested/later.txt b/nested/later.txt"); + } + assert_eq!( + final_diff + .lines() + .filter(|line| line.starts_with("diff --git")) + .collect::>(), + expected_headers, + ); assert_eq!(starts, 1); assert_eq!(client_ids, [Some("steer-id".to_string())]); let requests = responses.requests(); - assert_eq!(requests.len(), 2); + assert_eq!(requests.len(), expected_requests); assert_eq!( - requests[1] + requests[2] .message_input_texts("user") .iter() .filter(|text| *text == "late steer")