Lightweight coding agent that runs in your terminal
Rust
Install full context in compaction replacement history (#51117)
pakrym-oai8571b9eaa46e
diff --git a/codex-rs/core/src/compact.rs b/codex-rs/core/src/compact.rsindex 39919cfef6..83f9774074 100644--- a/codex-rs/core/src/compact.rs+++ b/codex-rs/core/src/compact.rs@@ -58,23 +58,6 @@ pub use codex_prompts::SUMMARIZATION_PROMPT;pub use codex_prompts::SUMMARY_PREFIX;const COMPACT_USER_MESSAGE_MAX_TOKENS: usize = 20_000;-/// Controls whether compaction replacement history must include initial context.-///-/// Pre-turn/manual compaction variants use `DoNotInject`: they replace history with a summary and-/// clear `reference_context_item`, so the next regular turn will fully reinject initial context-/// after compaction.-///-/// Mid-turn compaction must use `BeforeLastUserMessage` because the model is trained to see the-/// compaction summary as the last item in history after mid-turn compaction; we therefore inject-/// initial context into the replacement history just above the last real user message.-pub(crate) enum InitialContextInjection {- BeforeLastUserMessage {- world_state: Arc<WorldState>,- step_context: Arc<StepContext>,- },- DoNotInject,-}-/// Metadata for a new compaction checkpoint, kept separate from its replacement history.////// `Session::replace_compacted_history` assigns missing item IDs before constructing the persisted@@ -89,32 +72,28 @@ pub(crate) struct CompactedHistoryMetadata {pub(crate) reviewer_compaction_hash: Option<String>,}+/// Render replacement context and its comparison baseline from the same captured step.+/// Initial context is installed only after compaction returns, above the last real user message+/// (or the summary when no user message remains), keeping the compaction summary last.pub(crate) async fn build_compaction_initial_context(sess: &Session,- initial_context_injection: &InitialContextInjection,-) -> (Vec<ResponseItemEnvelope>, Option<WorldStateSnapshot>) {- // Return the rendered state with its items so history and its baseline stay identical.- match initial_context_injection {- InitialContextInjection::BeforeLastUserMessage {- world_state,- step_context,- } => {- let (items, snapshot) = sess- .build_initial_context_with_world_state(step_context, world_state.as_ref())- .await;- (- items.into_iter().map(ResponseItemEnvelope::new).collect(),- Some(snapshot),- )- }- InitialContextInjection::DoNotInject => (Vec::new(), None),- }+ step_context: &StepContext,+ world_state: &WorldState,+) -> (Vec<ResponseItemEnvelope>, WorldStateSnapshot) {+ let (items, snapshot) = sess+ .build_initial_context_with_world_state(step_context, world_state)+ .await;+ (+ items.into_iter().map(ResponseItemEnvelope::new).collect(),+ snapshot,+ )}pub(crate) async fn run_inline_auto_compact_task(sess: Arc<Session>,turn_context: Arc<TurnContext>,- initial_context_injection: InitialContextInjection,+ replacement_step_context: Arc<StepContext>,+ world_state: Arc<WorldState>,reason: CompactionReason,phase: CompactionPhase,) -> CodexResult<()> {@@ -133,11 +112,15 @@ pub(crate) async fn run_inline_auto_compact_task(run_compact_task_inner(sess,turn_context,+ replacement_step_context,input,- initial_context_injection,- CompactionTrigger::Auto,- reason,- phase,+ world_state,+ CompactionTurnMetadata::new(+ CompactionTrigger::Auto,+ reason,+ CompactionImplementation::Responses,+ phase,+ ),).await?;Ok(())@@ -145,18 +128,22 @@ pub(crate) async fn run_inline_auto_compact_task(pub(crate) async fn run_compact_task(sess: Arc<Session>,- turn_context: Arc<TurnContext>,+ step_context: Arc<StepContext>,+ world_state: Arc<WorldState>,input: Vec<UserInput>,) -> CodexResult<()> {- sess.emit_turn_started(&turn_context).await;run_compact_task_inner(sess.clone(),- turn_context,+ Arc::clone(&step_context.turn),+ step_context,input,- InitialContextInjection::DoNotInject,- CompactionTrigger::Manual,- CompactionReason::UserRequested,- CompactionPhase::StandaloneTurn,+ world_state,+ CompactionTurnMetadata::new(+ CompactionTrigger::Manual,+ CompactionReason::UserRequested,+ CompactionImplementation::Responses,+ CompactionPhase::StandaloneTurn,+ ),).await?;Ok(())@@ -165,14 +152,14 @@ pub(crate) async fn run_compact_task(async fn run_compact_task_inner(sess: Arc<Session>,turn_context: Arc<TurnContext>,+ replacement_step_context: Arc<StepContext>,input: Vec<UserInput>,- initial_context_injection: InitialContextInjection,- trigger: CompactionTrigger,- reason: CompactionReason,- phase: CompactionPhase,+ world_state: Arc<WorldState>,+ compaction_metadata: CompactionTurnMetadata,) -> CodexResult<()> {- let compaction_metadata =- CompactionTurnMetadata::new(trigger, reason, CompactionImplementation::Responses, phase);+ let trigger = compaction_metadata.trigger();+ let reason = compaction_metadata.reason();+ let phase = compaction_metadata.phase();let attempt = CompactionAnalyticsAttempt::begin(sess.as_ref(),turn_context.as_ref(),@@ -201,8 +188,9 @@ async fn run_compact_task_inner(let result = run_compact_task_inner_impl(Arc::clone(&sess),Arc::clone(&turn_context),+ replacement_step_context,input,- initial_context_injection,+ world_state,compaction_metadata,).await;@@ -250,8 +238,9 @@ async fn run_compact_task_inner(async fn run_compact_task_inner_impl(sess: Arc<Session>,turn_context: Arc<TurnContext>,+ replacement_step_context: Arc<StepContext>,input: Vec<UserInput>,- initial_context_injection: InitialContextInjection,+ world_state: Arc<WorldState>,compaction_metadata: CompactionTurnMetadata,) -> CodexResult<String> {let compaction_item = TurnItem::ContextCompaction(ContextCompactionItem::new());@@ -371,20 +360,13 @@ async fn run_compact_task_inner_impl(let (window_number, window_ids) = sess.advance_auto_compact_window().await;let (initial_context, world_state_baseline) =- build_compaction_initial_context(sess.as_ref(), &initial_context_injection).await;- if !initial_context.is_empty() {- new_history =- insert_initial_context_before_last_real_user_or_summary(new_history, initial_context);- }- let reference_context_item = match initial_context_injection {- InitialContextInjection::DoNotInject => None,- InitialContextInjection::BeforeLastUserMessage { step_context, .. } => {- Some(step_context.to_turn_context_item())- }- };+ build_compaction_initial_context(sess.as_ref(), &replacement_step_context, &world_state)+ .await;+ new_history =+ insert_initial_context_before_last_real_user_or_summary(new_history, initial_context);sess.replace_compacted_history(new_history,- reference_context_item,+ replacement_step_context.to_turn_context_item(),world_state_baseline,CompactedHistoryMetadata {input_goal_ids,@@ -397,7 +379,8 @@ async fn run_compact_task_inner_impl(},).await;- sess.recompute_token_usage(&turn_context).await;+ sess.recompute_token_usage(&replacement_step_context.turn)+ .await;sess.emit_turn_item_completed(&turn_context, compaction_item).await;diff --git a/codex-rs/core/src/compact_model_fallback.rs b/codex-rs/core/src/compact_model_fallback.rsindex 139c88879b..9e9a6213d5 100644--- a/codex-rs/core/src/compact_model_fallback.rs+++ b/codex-rs/core/src/compact_model_fallback.rs@@ -1,3 +1,4 @@+use crate::session::turn_context::TurnContext;use codex_analytics::CompactionImplementation;use codex_analytics::CompactionReason;use codex_otel::SessionTelemetry;@@ -6,13 +7,28 @@ use codex_protocol::error::CodexErrorDetails;use tracing::warn;/// Returns whether a failed compaction attempt should use the current model.-pub(crate) fn should_retry_with_current_model(error: &CodexErr) -> bool {- !matches!(+pub(crate) fn should_retry_with_current_model(+ error: &CodexErr,+ previous: &TurnContext,+ current: &TurnContext,+) -> bool {+ if matches!(error.details(),CodexErrorDetails::TurnAborted| CodexErrorDetails::Interrupted| CodexErrorDetails::SessionBudgetExceeded- )+ ) || (previous.model_info().slug == current.model_info().slug+ && previous.cyber_access_program == current.cyber_access_program)+ {+ return false;+ }++ current.provider.info().is_openai()+ && current+ .auth_manager+ .as_deref()+ .and_then(codex_login::AuthManager::auth_cached)+ .is_some_and(|auth| auth.uses_codex_backend() || auth.is_api_key_auth())}pub(crate) fn record_model_fallback(diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rsindex 56e4aace1b..e20b0a7f5c 100644--- a/codex-rs/core/src/compact_remote_v2.rs+++ b/codex-rs/core/src/compact_remote_v2.rs@@ -7,7 +7,6 @@ use crate::client_common::ResponseEvent;use crate::compact::CompactedHistoryMetadata;use crate::compact::CompactionAnalyticsAttempt;use crate::compact::CompactionAnalyticsDetails;-use crate::compact::InitialContextInjection;use crate::compact::build_compaction_initial_context;use crate::compact::compaction_status_from_result;use crate::compact::insert_initial_context_before_last_real_user_or_summary;@@ -15,6 +14,7 @@ use crate::compact_model_fallback::record_model_fallback;use crate::compact_model_fallback::should_retry_with_current_model;use crate::compact_remote_history::HistoryItemGroup;use crate::compact_remote_history::history_item_groups;+use crate::context::world_state::WorldState;use crate::context_manager::estimate_item_token_count;use crate::hook_runtime::PostCompactHookOutcome;use crate::hook_runtime::PreCompactHookOutcome;@@ -56,7 +56,6 @@ use codex_rollout_trace::InferenceTraceContext;use codex_utils_output_truncation::approx_token_count;use codex_utils_output_truncation::truncate_text;use futures::StreamExt;-use tokio_util::sync::CancellationToken;#[path = "compact_remote_v2_attempt.rs"]mod attempt;@@ -81,9 +80,9 @@ const MAX_REMOTE_COMPACTION_V2_STREAM_RETRIES: u64 = 2;pub(crate) async fn run_inline_remote_auto_compact_task(sess: Arc<Session>,step_context: Arc<StepContext>,- fallback_step_context: Option<Arc<StepContext>>,+ replacement_step_context: Arc<StepContext>,client_session: &mut ModelClientSession,- initial_context_injection: InitialContextInjection,+ world_state: Arc<WorldState>,reason: CompactionReason,phase: CompactionPhase,) -> CodexResult<()> {@@ -96,9 +95,9 @@ pub(crate) async fn run_inline_remote_auto_compact_task(run_remote_compact_task_inner(&sess,&step_context,- fallback_step_context.as_ref(),+ &replacement_step_context,Some(client_session),- initial_context_injection,+ world_state,compaction_metadata,).await@@ -106,14 +105,9 @@ pub(crate) async fn run_inline_remote_auto_compact_task(pub(crate) async fn run_remote_compact_task(sess: Arc<Session>,- turn_context: Arc<TurnContext>,+ step_context: Arc<StepContext>,+ world_state: Arc<WorldState>,) -> CodexResult<()> {- // Standalone compaction is its own request boundary, so it captures a fresh step.- let step_context = sess- .capture_step_context(Arc::clone(&turn_context), &CancellationToken::new())- .await?;- sess.emit_turn_started(&turn_context).await;-let compaction_metadata = CompactionTurnMetadata::new(CompactionTrigger::Manual,CompactionReason::UserRequested,@@ -123,9 +117,9 @@ pub(crate) async fn run_remote_compact_task(run_remote_compact_task_inner(&sess,&step_context,- /*fallback_step_context*/ None,+ &step_context,/*client_session*/ None,- InitialContextInjection::DoNotInject,+ world_state,compaction_metadata,).await@@ -134,9 +128,9 @@ pub(crate) async fn run_remote_compact_task(async fn run_remote_compact_task_inner(sess: &Arc<Session>,step_context: &Arc<StepContext>,- fallback_step_context: Option<&Arc<StepContext>>,+ replacement_step_context: &Arc<StepContext>,client_session: Option<&mut ModelClientSession>,- initial_context_injection: InitialContextInjection,+ world_state: Arc<WorldState>,compaction_metadata: CompactionTurnMetadata,) -> CodexResult<()> {let turn_context = &step_context.turn;@@ -176,9 +170,9 @@ async fn run_remote_compact_task_inner(let result = run_remote_compact_task_inner_impl(sess,step_context,- fallback_step_context,+ replacement_step_context,client_session,- initial_context_injection,+ world_state,compaction_metadata,&mut analytics_details,)@@ -222,9 +216,9 @@ async fn run_remote_compact_task_inner(async fn run_remote_compact_task_inner_impl(sess: &Arc<Session>,step_context: &Arc<StepContext>,- fallback_step_context: Option<&Arc<StepContext>>,+ replacement_step_context: &Arc<StepContext>,mut client_session: Option<&mut ModelClientSession>,- initial_context_injection: InitialContextInjection,+ world_state: Arc<WorldState>,compaction_metadata: CompactionTurnMetadata,analytics_details: &mut CompactionAnalyticsDetails,) -> CodexResult<()> {@@ -253,15 +247,12 @@ async fn run_remote_compact_task_inner_impl(let (attempt, compaction_turn_context) = match attempt {Ok(attempt) => (attempt, turn_context),Err(error) => {- let Some(fallback_step_context) = fallback_step_context else {- return Err(error);- };- if !should_retry_with_current_model(&error) {+ let fallback_turn_context = &replacement_step_context.turn;+ if !should_retry_with_current_model(&error, turn_context, fallback_turn_context) {return Err(error);}- sess.set_last_known_step_context(fallback_step_context)+ sess.set_last_known_step_context(replacement_step_context).await;- let fallback_turn_context = &fallback_step_context.turn;let fallback_compaction_trace =sess.services.rollout_thread_trace.compaction_trace_context(fallback_turn_context.sub_id.as_str(),@@ -271,7 +262,7 @@ async fn run_remote_compact_task_inner_impl();let fallback_result = run_remote_compact_v2_attempt(sess,- fallback_step_context,+ replacement_step_context,client_session,&fallback_compaction_trace,compaction_metadata,@@ -323,16 +314,11 @@ async fn run_remote_compact_task_inner_impl(analytics_details.retained_image_count = Some(retained_images);let (new_window_number, new_window_ids) = sess.advance_auto_compact_window().await;let (initial_context, world_state_baseline) =- build_compaction_initial_context(sess.as_ref(), &initial_context_injection).await;+ build_compaction_initial_context(sess.as_ref(), replacement_step_context, &world_state)+ .await;let new_history =insert_initial_context_before_last_real_user_or_summary(compacted_history, initial_context);- let reference_context_item = match initial_context_injection {- InitialContextInjection::DoNotInject => None,- InitialContextInjection::BeforeLastUserMessage { step_context, .. } => {- Some(step_context.to_turn_context_item())- }- };if let Some(trace_input_history) = trace_input_history.as_deref() {let replacement_history = new_history.iter()@@ -359,7 +345,7 @@ async fn run_remote_compact_task_inner_impl(};sess.replace_compacted_history(new_history,- reference_context_item,+ replacement_step_context.to_turn_context_item(),world_state_baseline,CompactedHistoryMetadata {input_goal_ids,@@ -372,7 +358,8 @@ async fn run_remote_compact_task_inner_impl(},).await;- sess.recompute_token_usage(compaction_turn_context).await;+ sess.recompute_token_usage(&replacement_step_context.turn)+ .await;sess.emit_turn_item_completed(compaction_turn_context, compaction_item).await;diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rsindex 19d6ed2e5d..a407ffcb33 100644--- a/codex-rs/core/src/compact_tests.rs+++ b/codex-rs/core/src/compact_tests.rs@@ -157,10 +157,15 @@ async fn local_compaction_respects_tool_metadata_state(]),).await;+ let step = session+ .capture_step_context(turn, &tokio_util::sync::CancellationToken::new())+ .await?;+ let world_state = Arc::new(session.build_world_state_for_step(&step).await?);// OpenAI identity keeps the client from removing passthrough for compatibility.run_compact_task(Arc::clone(&session),- turn,+ step,+ world_state,vec![UserInput::Text {text: "Summarize the conversation.".to_string(),text_elements: Vec::new(),diff --git a/codex-rs/core/src/compact_token_budget.rs b/codex-rs/core/src/compact_token_budget.rsindex 3e6ce1beaa..3d97b6864a 100644--- a/codex-rs/core/src/compact_token_budget.rs+++ b/codex-rs/core/src/compact_token_budget.rs@@ -1,6 +1,5 @@use std::sync::Arc;-use crate::compact::InitialContextInjection;use crate::context::world_state::WorldState;use crate::hook_runtime::PostCompactHookOutcome;use crate::hook_runtime::PreCompactHookOutcome;@@ -8,13 +7,11 @@ use crate::hook_runtime::run_post_compact_hooks;use crate::hook_runtime::run_pre_compact_hooks;use crate::session::session::Session;use crate::session::step_context::StepContext;-use crate::session::turn_context::TurnContext;use codex_analytics::CompactionTrigger;use codex_protocol::error::CodexErr;use codex_protocol::error::Result as CodexResult;use codex_protocol::items::ContextCompactionItem;use codex_protocol::items::TurnItem;-use tokio_util::sync::CancellationToken;/// Runs token-budget manual compaction as a normal compaction lifecycle.///@@ -23,15 +20,9 @@ use tokio_util::sync::CancellationToken;/// observe the same lifecycle as local or remote compaction.pub(crate) async fn run_manual_compact_task(sess: Arc<Session>,- turn_context: Arc<TurnContext>,+ step_context: Arc<StepContext>,+ world_state: Arc<WorldState>,) -> CodexResult<()> {- sess.emit_turn_started(&turn_context).await;-- // Manual compaction runs outside run_turn, so it captures its own current step.- let step_context = sess- .capture_step_context(Arc::clone(&turn_context), &CancellationToken::new())- .await?;- let world_state = Arc::new(sess.build_world_state_for_step(&step_context).await?);run_compact_task_inner(&sess, &step_context, world_state, CompactionTrigger::Manual).await}@@ -43,14 +34,8 @@ pub(crate) async fn run_manual_compact_task(pub(crate) async fn run_inline_auto_compact_task(sess: Arc<Session>,step_context: Arc<StepContext>,- initial_context_injection: InitialContextInjection,+ world_state: Arc<WorldState>,) -> CodexResult<()> {- let world_state = match initial_context_injection {- InitialContextInjection::BeforeLastUserMessage { world_state, .. } => world_state,- InitialContextInjection::DoNotInject => {- Arc::new(sess.build_world_state_for_step(&step_context).await?)- }- };run_compact_task_inner(&sess, &step_context, world_state, CompactionTrigger::Auto).await}diff --git a/codex-rs/core/src/guardian/review_session_tests.rs b/codex-rs/core/src/guardian/review_session_tests.rsindex 7414760c66..b1fd75b719 100644--- a/codex-rs/core/src/guardian/review_session_tests.rs+++ b/codex-rs/core/src/guardian/review_session_tests.rs@@ -82,8 +82,8 @@ async fn run_review_preserves_evidence_during_parent_compaction() {parent.replace_compacted_history(vec![checkpoint.into()],- /*reference_context_item*/ None,- /*world_state_baseline*/ None,+ turn.to_turn_context_item(),+ crate::context::world_state::WorldStateSnapshot::default(),crate::compact::CompactedHistoryMetadata {input_goal_ids: Default::default(),message: String::new(),diff --git a/codex-rs/core/src/guardian/tests.rs b/codex-rs/core/src/guardian/tests.rsindex 88792b6dda..bd4de5a580 100644--- a/codex-rs/core/src/guardian/tests.rs+++ b/codex-rs/core/src/guardian/tests.rs@@ -2654,8 +2654,8 @@ async fn guardian_reuses_prompt_cache_key_and_appends_prior_reviews() -> anyhow:.into_iter().map(codex_history::ResponseItemEnvelope::new).collect(),- /*reference_context_item*/ None,- /*world_state_baseline*/ None,+ turn.to_turn_context_item(),+ crate::context::world_state::WorldStateSnapshot::default(),crate::compact::CompactedHistoryMetadata {input_goal_ids: Default::default(),message: String::new(),diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex dea3a06f0d..7b14f934c9 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -3993,8 +3993,8 @@ impl Session {pub(crate) async fn replace_compacted_history(&self,mut items: Vec<ResponseItemEnvelope>,- reference_context_item: Option<TurnContextItem>,- world_state_baseline: Option<WorldStateSnapshot>,+ reference_context_item: TurnContextItem,+ world_state_baseline: WorldStateSnapshot,metadata: CompactedHistoryMetadata,) {for envelope in &mut items {@@ -4024,20 +4024,9 @@ impl Session {// Wait for accepted updates to finish persisting, then keep later updates from// overtaking the current settings snapshot while its checkpoint is written.let _settings_guard = thread_settings::acquire_persistence_lock(self).await;- // A new history window needs a full checkpoint, even when it contains only- // extension metadata and model-visible context will be rebuilt on the next turn.- let mut world_state_item = None;+ let world_state_item = WorldStateItem::full(world_state_baseline.clone().into_object());let compacted_item = {let mut state = self.state.lock().await;- let snapshot = world_state_baseline.or_else(|| {- let previous = state.history.world_state_checkpoint()?;- let mut retained = serde_json::Map::new();- for contributor in self.services.extensions.context_contributors() {- retained- .extend(contributor.retain_world_state_after_compaction(&previous.state));- }- (!retained.is_empty()).then(|| WorldStateSnapshot::from(&retained))- });// Goal edits are published outside the running task. Keep edits accepted after// the compaction input snapshot, in their original order, after its replacement.let replacement_goal_ids = crate::context::UserGoalUpdate::message_ids(@@ -4060,16 +4049,13 @@ impl Session {let replacement_history = items.clone();state.replace_annotated_history(items,- reference_context_item.clone(),+ Some(reference_context_item.clone()),HistoryReplacement::Compaction {reviewer_compaction_hash: metadata.reviewer_compaction_hash,},);state.reasoning_effort_pin = ReasoningEffortPin::Compacted;- if let Some(snapshot) = snapshot {- world_state_item = Some(WorldStateItem::full(snapshot.clone().into_object()));- state.history.set_world_state_baseline(snapshot);- }+ state.history.set_world_state_baseline(world_state_baseline);CompactedItem {message: metadata.message,replacement_history: Some(replacement_history),@@ -4093,18 +4079,13 @@ impl Session {}};- let mut rollout_items = vec![RolloutItem::Compacted(compacted_item)];- // Persist the baseline after the replacement history that established it.- if let Some(world_state_item) = world_state_item {- rollout_items.push(RolloutItem::WorldState(world_state_item));- }- if let Some(turn_context_item) = reference_context_item {- rollout_items.push(RolloutItem::TurnContext(turn_context_item));- }- // The frozen turn context must not override current settings in persisted metadata.- rollout_items.push(RolloutItem::EventMsg(- thread_settings::applied_event(self).await,- ));+ let rollout_items = [+ RolloutItem::Compacted(compacted_item),+ RolloutItem::WorldState(world_state_item),+ RolloutItem::TurnContext(reference_context_item),+ // The frozen turn context must not override current settings in persisted metadata.+ RolloutItem::EventMsg(thread_settings::applied_event(self).await),+ ];if self.persist_rollout_items(&rollout_items).await&& let Some(revision) = mcp_revision{@@ -4573,8 +4554,8 @@ impl Session {let turn_context_item = step_context.to_turn_context_item();self.replace_compacted_history(context_items,- Some(turn_context_item),- Some(world_state_snapshot),+ turn_context_item,+ world_state_snapshot,CompactedHistoryMetadata {input_goal_ids,message: String::new(),@@ -4605,8 +4586,8 @@ impl Session {/// `<model_switch>` developer message so model-specific instructions are not lost.////// This is the normal runtime path that establishes a new `reference_context_item`.- /// Mid-turn compaction is the other path that can re-establish that reference when it- /// reinjects full initial context into replacement history. Live world-state changes may+ /// Compaction also establishes that reference when it installs full initial context+ /// into replacement history. Live world-state changes may/// independently advance their in-memory baseline within a turn.#[instrument(level = "trace", skip_all)]pub(crate) async fn record_context_updates_and_set_reference_context_item(diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 1c6bfab190..8e13dbf102 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -15,7 +15,6 @@ use super::*;mod config_refresh_tests;use crate::agents_md_manager::AgentsMdManager;use crate::agents_md_manager::SessionInstructions;-use crate::compact::InitialContextInjection;use crate::config::ConfigBuilder;use crate::config::ConfigOverrides;use crate::config::RuntimeConfigRefresh;@@ -5854,7 +5853,7 @@ async fn session_configuration_apply_preserves_absolute_cwd_write_root_on_cwd_up#[tokio::test]async fn settings_checkpoint_waits_for_accepted_settings_persistence() {- let (mut session, _turn_context, rx) = make_session_and_context_with_auth_and_config_and_rx(+ let (mut session, turn_context, rx) = make_session_and_context_with_auth_and_config_and_rx(CodexAuth::from_api_key("Test API Key"),Vec::new(),|config| {@@ -5892,8 +5891,8 @@ async fn settings_checkpoint_waits_for_accepted_settings_persistence() {let mut checkpoint = Box::pin(tokio::task::unconstrained(session.replace_compacted_history(vec![ResponseItemEnvelope::new(user_message("compacted history"))],- /*reference_context_item*/ None,- /*world_state_baseline*/ None,+ turn_context.to_turn_context_item(),+ WorldStateSnapshot::default(),CompactedHistoryMetadata {input_goal_ids: Default::default(),message: "summary".to_string(),@@ -6026,8 +6025,8 @@ async fn mcp_attribution_checkpoints_cover_batch_prefixes_compaction_and_restoresession.replace_compacted_history(vec![ResponseItemEnvelope::new(user_message("compacted history"))],- /*reference_context_item*/ None,- /*world_state_baseline*/ None,+ turn_context.to_turn_context_item(),+ WorldStateSnapshot::default(),CompactedHistoryMetadata {input_goal_ids: Default::default(),message: "summary".to_string(),@@ -6154,48 +6153,39 @@ async fn compaction_persists_resume_metadata_and_companion_records() {thread_settings: session.thread_settings_snapshot().await,};- let mut first_live_history = None;- for with_baselines in [true, false] {- let input_goal_ids =- crate::context::UserGoalUpdate::message_ids(session.clone_history().await.raw_items());- // The goal edit is accepted after the compaction input was captured.- let accepted_goal = if with_baselines {- session- .record_user_goal_update(crate::context::UserGoalUpdate::Clear)- .await- .expect("record concurrent clear");- session- .clone_history()- .await- .annotated_items()- .last()- .cloned()- } else {- None- };- let (window_number, window_ids) = session.advance_auto_compact_window().await;- session- .replace_compacted_history(- vec![ResponseItemEnvelope::new(user_message("compacted context"))],- with_baselines.then_some(turn_context_baseline.clone()),- with_baselines.then(|| world_state.render_full().0),- CompactedHistoryMetadata {- input_goal_ids,- message: String::new(),- window_number,- window_ids,- compaction_response_id: None,- compaction_model_hash: None,- reviewer_compaction_hash: None,- },- )- .await;- if let Some(accepted_goal) = accepted_goal {- let live_history = session.clone_history().await.annotated_items().to_vec();- assert_eq!(&live_history[1..], &[accepted_goal]);- first_live_history = Some(live_history);- }- }+ let input_goal_ids =+ crate::context::UserGoalUpdate::message_ids(session.clone_history().await.raw_items());+ // The goal edit is accepted after the compaction input was captured.+ session+ .record_user_goal_update(crate::context::UserGoalUpdate::Clear)+ .await+ .expect("record concurrent clear");+ let accepted_goal = session+ .clone_history()+ .await+ .annotated_items()+ .last()+ .cloned()+ .expect("accepted goal");+ let (window_number, window_ids) = session.advance_auto_compact_window().await;+ session+ .replace_compacted_history(+ vec![ResponseItemEnvelope::new(user_message("compacted context"))],+ turn_context_baseline.clone(),+ world_state.render_full().0,+ CompactedHistoryMetadata {+ input_goal_ids,+ message: String::new(),+ window_number,+ window_ids,+ compaction_response_id: None,+ compaction_model_hash: None,+ reviewer_compaction_hash: None,+ },+ )+ .await;+ let live_history = session.clone_history().await.annotated_items().to_vec();+ assert_eq!(&live_history[1..], &[accepted_goal]);session.flush_rollout().await.expect("flush checkpoints");let (items, _, _) = RolloutRecorder::load_rollout_items(&rollout_path)@@ -6206,26 +6196,22 @@ async fn compaction_persists_resume_metadata_and_companion_records() {.skip_while(|item| !matches!(item, RolloutItem::Compacted(_))).collect::<Vec<_>>();let [- RolloutItem::Compacted(first),- RolloutItem::WorldState(first_world_state),- RolloutItem::TurnContext(first_turn_context),- RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(first_settings)),- RolloutItem::Compacted(second),- RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(second_settings)),+ RolloutItem::Compacted(compacted),+ RolloutItem::WorldState(saved_world_state),+ RolloutItem::TurnContext(saved_turn_context),+ RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(saved_settings)),] = compaction_items.as_slice()else {panic!("unexpected compaction records: {compaction_items:#?}");};- assert_eq!(first.replacement_history, first_live_history);- assert_eq!(first.resume_metadata.as_ref(), Some(&expected));- assert_eq!(second.resume_metadata.as_ref(), Some(&expected));+ assert_eq!(compacted.replacement_history, Some(live_history));+ assert_eq!(compacted.resume_metadata.as_ref(), Some(&expected));assert_eq!(- first_world_state,+ saved_world_state,&WorldStateItem::full(world_state.render_full().0.into_object()));- assert_eq!(first_turn_context, &turn_context_baseline);- assert_eq!(first_settings, &expected_settings);- assert_eq!(second_settings, &expected_settings);+ assert_eq!(saved_turn_context, &turn_context_baseline);+ assert_eq!(saved_settings, &expected_settings);}#[tokio::test]@@ -11312,12 +11298,8 @@ async fn build_initial_context_uses_retained_step_after_model_change() {.await.unwrap();let world_a = Arc::new(session.build_world_state_for_step(&step_a).await.unwrap());- let retained = crate::compact::InitialContextInjection::BeforeLastUserMessage {- world_state: Arc::clone(&world_a),- step_context: Arc::clone(&step_a),- };let (initial_a, _) =- crate::compact::build_compaction_initial_context(&session, &retained).await;+ crate::compact::build_compaction_initial_context(&session, &step_a, &world_a).await;let mut selected_b = step_a.settings.selected().clone();selected_b.collaboration_mode.settings.model = "model-b".to_string();@@ -11348,10 +11330,10 @@ async fn build_initial_context_uses_retained_step_after_model_change() {.0;let turn_contributions_b = session.build_turn_context_contribution_items(&step_b).await;let (restored_a, restored_snapshot) =- crate::compact::build_compaction_initial_context(&session, &retained).await;+ crate::compact::build_compaction_initial_context(&session, &step_a, &world_a).await;assert_eq!(restored_a, initial_a);- assert_eq!(restored_snapshot, Some(world_a.render_full().0));+ assert_eq!(restored_snapshot, world_a.render_full().0);let initial_a = initial_a.into_iter().map(ResponseItemEnvelope::into_item)@@ -11943,9 +11925,9 @@ async fn remote_compaction_v2_retains_only_the_selected_step(first_attempt: Firscrate::compact_remote_v2::run_inline_remote_auto_compact_task(Arc::clone(&session),Arc::clone(&primary),- Some(Arc::clone(&fallback)),+ Arc::clone(&fallback),&mut client_session,- InitialContextInjection::DoNotInject,+ Arc::new(session.build_world_state_for_step(&fallback).await.unwrap()),CompactionReason::ModelDownshift,CompactionPhase::PreTurn,)diff --git a/codex-rs/core/src/session/tests/guardian_tests.rs b/codex-rs/core/src/session/tests/guardian_tests.rsindex 59a65e10a6..6eee4d3939 100644--- a/codex-rs/core/src/session/tests/guardian_tests.rs+++ b/codex-rs/core/src/session/tests/guardian_tests.rs@@ -1,5 +1,4 @@use super::*;-use crate::compact::InitialContextInjection;use crate::config::Constrained;use crate::exec_policy::ExecPolicyManager;use crate::guardian::GUARDIAN_REVIEWER_NAME;@@ -1118,13 +1117,8 @@ async fn compaction_initial_context_preserves_separate_guardian_developer_messag.await.expect("world state should build"),);- let initial_context_injection = InitialContextInjection::BeforeLastUserMessage {- world_state,- step_context,- };-let (refreshed, _) =- crate::compact::build_compaction_initial_context(&session, &initial_context_injection)+ crate::compact::build_compaction_initial_context(&session, &step_context, &world_state).await;let developer_messages = refresheddiff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex b5147caa73..413b3103e3 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -6,12 +6,12 @@ use std::sync::atomic::Ordering;use crate::client::ModelClientSession;use crate::client_common::Prompt;use crate::client_common::ResponseEvent;-use crate::compact::InitialContextInjection;use crate::compact::run_inline_auto_compact_task;use crate::compact_remote_v2::run_inline_remote_auto_compact_task as run_inline_remote_auto_compact_task_v2;use crate::connectors;use crate::context::ContextualUserFragment;use crate::context::UserVerificationNotice;+use crate::context::world_state::WorldState;use crate::cyber_access_program;use crate::environment_selection::TurnEnvironmentSnapshot;use crate::feedback_tags;@@ -346,9 +346,9 @@ pub(crate) async fn run_turn(run_auto_compact(&sess,Arc::clone(&first_step_context),- /*fallback_step_context*/ None,+ Arc::clone(&first_step_context),&mut client_session,- InitialContextInjection::DoNotInject,+ Arc::clone(&world_state),CompactionReason::ContextLimit,CompactionPhase::PreTurn,)@@ -614,12 +614,9 @@ pub(crate) async fn run_turn(if let Err(err) = run_auto_compact(&sess,Arc::clone(&step_context),- /*fallback_step_context*/ None,+ Arc::clone(&step_context),&mut client_session,- InitialContextInjection::BeforeLastUserMessage {- world_state: Arc::clone(&world_state),- step_context: Arc::clone(&step_context),- },+ Arc::clone(&world_state),CompactionReason::ContextLimit,CompactionPhase::MidTurn,)@@ -726,9 +723,9 @@ pub(crate) async fn run_turn(&& let Err(err) = run_auto_compact(&sess,Arc::clone(&step_context),- /*fallback_step_context*/ None,+ Arc::clone(&step_context),&mut client_session,- InitialContextInjection::DoNotInject,+ Arc::clone(&world_state),CompactionReason::ContextLimit,CompactionPhase::PostTurn,)@@ -777,12 +774,9 @@ pub(crate) async fn run_turn(run_auto_compact(&sess,Arc::clone(&step_context),- /*fallback_step_context*/ None,+ Arc::clone(&step_context),&mut client_session,- InitialContextInjection::BeforeLastUserMessage {- world_state: Arc::clone(&world_state),- step_context: Arc::clone(&step_context),- },+ Arc::clone(&world_state),CompactionReason::ContextLimit,CompactionPhase::MidTurn,)@@ -1318,12 +1312,13 @@ async fn run_pre_sampling_compact(let step_context = sess.capture_step_context(Arc::clone(turn_context), cancellation_token).await?;+ let world_state = Arc::new(sess.build_world_state_for_step(&step_context).await?);run_auto_compact(sess,+ Arc::clone(&step_context),step_context,- /*fallback_step_context*/ None,client_session,- InitialContextInjection::DoNotInject,+ world_state,CompactionReason::ContextLimit,CompactionPhase::PreTurn,)@@ -1340,33 +1335,6 @@ fn comp_hash_changed(previous: Option<&str>, current: Option<&str>) -> bool {.is_some_and(|(previous, current)| previous != current)}-/// Captures the current model's request-scoped state for retrying previous-model compaction.-///-/// Returns `None` when auth uses neither the Codex backend nor an API key, the provider is-/// not OpenAI, or the previous and current model/program pairs are the same.-async fn capture_current_model_fallback_step_context(- sess: &Arc<Session>,- turn_context: &Arc<TurnContext>,- previous_turn_context: &TurnContext,- cancellation_token: &CancellationToken,-) -> CodexResult<Option<Arc<StepContext>>> {- let supports_fallback = turn_context- .auth_manager- .as_deref()- .and_then(codex_login::AuthManager::auth_cached)- .is_some_and(|auth| auth.uses_codex_backend() || auth.is_api_key_auth());- if !supports_fallback- || !turn_context.provider.info().is_openai()- || (previous_turn_context.model_info().slug == turn_context.model_info().slug- && previous_turn_context.cyber_access_program == turn_context.cyber_access_program)- {- return Ok(None);- }- sess.capture_speculative_step_context(Arc::clone(turn_context), cancellation_token)- .await- .map(Some)-}-/// Runs pre-sampling compaction against the previous model when its compaction compatibility/// hash changed or when switching to a smaller context-window model.///@@ -1401,79 +1369,65 @@ async fn maybe_run_previous_model_inline_compact();let previous_model_turn_context = Arc::new(previous_model_turn_context);- if should_compact_for_comp_hash_change {- let step_context = sess- .capture_step_context(Arc::clone(&previous_model_turn_context), cancellation_token)- .await?;- let fallback_step_context = capture_current_model_fallback_step_context(- sess,- turn_context,- &previous_model_turn_context,- cancellation_token,- )- .await?;- run_auto_compact(- sess,- step_context,- fallback_step_context,- client_session,- InitialContextInjection::DoNotInject,- CompactionReason::CompHashChanged,- CompactionPhase::PreTurn,- )- .await?;- return Ok(());- }-- let Some(old_context_window) = previous_model_turn_context.model_context_window() else {- return Ok(());- };- let Some(new_context_window) = turn_context.model_context_window() else {- return Ok(());- };- let active_context_tokens = sess.get_total_token_usage().await;- let previous_model_limit_reached = match turn_context- .config- .model_auto_compact_token_limit_scope- {- AutoCompactTokenLimitScope::Total => {- let new_auto_compact_limit = turn_context- .model_info()- .auto_compact_token_limit()- .unwrap_or(i64::MAX);- active_context_tokens > new_auto_compact_limit- || active_context_tokens >= new_context_window+ let reason = if should_compact_for_comp_hash_change {+ CompactionReason::CompHashChanged+ } else {+ let Some(old_context_window) = previous_model_turn_context.model_context_window() else {+ return Ok(());+ };+ let Some(new_context_window) = turn_context.model_context_window() else {+ return Ok(());+ };+ let active_context_tokens = sess.get_total_token_usage().await;+ let previous_model_limit_reached =+ match turn_context.config.model_auto_compact_token_limit_scope {+ AutoCompactTokenLimitScope::Total => {+ let new_auto_compact_limit = turn_context+ .model_info()+ .auto_compact_token_limit()+ .unwrap_or(i64::MAX);+ active_context_tokens > new_auto_compact_limit+ || active_context_tokens >= new_context_window+ }+ AutoCompactTokenLimitScope::BodyAfterPrefix => {+ active_context_tokens >= new_context_window+ }+ };+ if !previous_model_limit_reached+ || previous_model_turn_context.model_info().slug == turn_context.model_info().slug+ || old_context_window <= new_context_window+ {+ return Ok(());}- AutoCompactTokenLimitScope::BodyAfterPrefix => active_context_tokens >= new_context_window,+ CompactionReason::ModelDownshift};- let should_run = previous_model_limit_reached- && previous_model_turn_context.model_info().slug != turn_context.model_info().slug- && old_context_window > new_context_window;- if should_run {- let step_context = sess- .capture_step_context(Arc::clone(&previous_model_turn_context), cancellation_token)- .await?;- let fallback_step_context = capture_current_model_fallback_step_context(- sess,- turn_context,- &previous_model_turn_context,- cancellation_token,- )++ let step_context = sess+ .capture_step_context(previous_model_turn_context, cancellation_token).await?;- run_auto_compact(- sess,- step_context,- fallback_step_context,- client_session,- InitialContextInjection::DoNotInject,- CompactionReason::ModelDownshift,- CompactionPhase::PreTurn,- )+ // The previous model summarizes the old window; the current model owns its replacement.+ // Reuse the replacement step if the compaction request needs to fall back to that model.+ let replacement_step_context = sess+ .capture_speculative_step_context(Arc::clone(turn_context), cancellation_token).await?;- }+ let world_state = Arc::new(+ sess.build_world_state_for_step(&replacement_step_context)+ .await?,+ );+ run_auto_compact(+ sess,+ step_context,+ replacement_step_context,+ client_session,+ world_state,+ reason,+ CompactionPhase::PreTurn,+ )+ .await?;Ok(())}+/// `world_state` belongs to `replacement_step_context`, which may differ from the compactor.#[instrument(level = "trace",skip_all,@@ -1482,9 +1436,9 @@ async fn maybe_run_previous_model_inline_compact(async fn run_auto_compact(sess: &Arc<Session>,step_context: Arc<StepContext>,- fallback_step_context: Option<Arc<StepContext>>,+ replacement_step_context: Arc<StepContext>,client_session: &mut ModelClientSession,- initial_context_injection: InitialContextInjection,+ world_state: Arc<WorldState>,reason: CompactionReason,phase: CompactionPhase,) -> CodexResult<()> {@@ -1501,8 +1455,8 @@ async fn run_auto_compact(// instead of consuming a pending `new_context` tool request.crate::compact_token_budget::run_inline_auto_compact_task(Arc::clone(sess),- step_context,- initial_context_injection,+ replacement_step_context,+ world_state,).await?;return Ok(());@@ -1518,9 +1472,9 @@ async fn run_auto_compact(run_inline_remote_auto_compact_task_v2(Arc::clone(sess),step_context,- fallback_step_context,+ replacement_step_context,client_session,- initial_context_injection,+ world_state,reason,phase,)@@ -1535,7 +1489,8 @@ async fn run_auto_compact(run_inline_auto_compact_task(Arc::clone(sess),Arc::clone(turn_context),- initial_context_injection,+ replacement_step_context,+ world_state,reason,phase,)diff --git a/codex-rs/core/src/tasks/compact.rs b/codex-rs/core/src/tasks/compact.rsindex baa8a639e1..62808c9e60 100644--- a/codex-rs/core/src/tasks/compact.rs+++ b/codex-rs/core/src/tasks/compact.rs@@ -31,7 +31,7 @@ impl SessionTask for CompactTask {session: Arc<Session>,ctx: Arc<TurnContext>,_input: Vec<TurnInput>,- _cancellation_token: CancellationToken,+ cancellation_token: CancellationToken,) -> SessionTaskResult {let _profile_guard = ctx.turn_timing_state.begin_compaction();let _compaction_span = tracing::trace_span!(@@ -40,8 +40,19 @@ impl SessionTask for CompactTask {conversation.id = %session.thread_id,turn.id = %ctx.sub_id,);+ // Preparation errors must reach the task runner, which reports them to the client.+ session.emit_turn_started(&ctx).await;+ let step_context = session+ .capture_step_context(Arc::clone(&ctx), &cancellation_token)+ .await?;+ let world_state = Arc::new(session.build_world_state_for_step(&step_context).await?);if ctx.config.features.enabled(Feature::TokenBudget) {- crate::compact_token_budget::run_manual_compact_task(session, ctx).await?;+ crate::compact_token_budget::run_manual_compact_task(+ session,+ step_context,+ world_state,+ )+ .await?;return Ok(None);}@@ -52,8 +63,12 @@ impl SessionTask for CompactTask {"remote_v2",/*manual*/ true,);- crate::compact_remote_v2::run_remote_compact_task(session.clone(), Arc::clone(&ctx))- .await+ crate::compact_remote_v2::run_remote_compact_task(+ session.clone(),+ step_context,+ world_state,+ )+ .await}RemoteCompactionSupport::Unsupported => {emit_compact_metric(@@ -71,7 +86,8 @@ impl SessionTask for CompactTask {// Compaction prompt is synthesized; no UI element ranges to preserve.text_elements: Vec::new(),}];- crate::compact::run_compact_task(session.clone(), Arc::clone(&ctx), input).await+ crate::compact::run_compact_task(session.clone(), step_context, world_state, input)+ .await}};if let Err(err) = result {diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rsindex 08a9df5d9b..080a161dad 100644--- a/codex-rs/core/tests/suite/compact.rs+++ b/codex-rs/core/tests/suite/compact.rs@@ -735,7 +735,7 @@ async fn summarize_context_three_requests_and_instructions(// Verify rollout contains user-turn TurnContext entries and a Compacted entry.println!("rollout path: {}", rollout_path.display());let text = std::fs::read_to_string(&rollout_path).expect("failed to read rollout file");- let mut regular_turn_context_count = 0usize;+ let mut turn_context_count = 0usize;let mut saw_compacted_summary = false;for line in text.lines() {let trimmed = line.trim();@@ -747,7 +747,7 @@ async fn summarize_context_three_requests_and_instructions(};match entry.item {RolloutItem::TurnContext(_) => {- regular_turn_context_count += 1;+ turn_context_count += 1;}RolloutItem::Compacted(ci) if ci.message == expected_summary_message => {let summary_item = ci@@ -780,8 +780,8 @@ async fn summarize_context_three_requests_and_instructions(}assert_eq!(- regular_turn_context_count, 2,- "rollout should contain one TurnContext entry per real user turn"+ turn_context_count, 3,+ "rollout should contain two user-turn contexts and the compaction baseline");assert!(saw_compacted_summary,@@ -4463,15 +4463,10 @@ async fn manual_compact_twice_preserves_latest_user_messages() {final_request_last_user_text, final_user_message,"final turn request should end with the submitted user message");- let history_before_seeded_prefix = final_request_before_last_user- .strip_suffix(initial_seeded_user_prefix)- .expect("final request should end with the seeded user prefix from the first request");- let expected_history = vec![- first_user_message.to_string(),- second_user_message.to_string(),- expected_second_summary,- ];- assert_eq!(history_before_seeded_prefix, expected_history.as_slice());+ let mut expected_history = vec![first_user_message.to_string()];+ expected_history.extend_from_slice(initial_seeded_user_prefix);+ expected_history.extend([second_user_message.to_string(), expected_second_summary]);+ assert_eq!(final_request_before_last_user, expected_history.as_slice());}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]@@ -5825,8 +5820,8 @@ async fn remote_v2_compaction_refreshes_instructions_and_preserves_them_on_cold_let replacement_history = replacement_history_from_rollout(&rollout_path)?;assert_eq!(instruction_fragments_in_items(&replacement_history),- Vec::<String>::new(),- "remote-v2 replacement history currently omits the global-instruction fragment"+ vec![new_fragment.clone()],+ "remote-v2 replacement history includes refreshed global instructions");assert_eq!(test.codex.instruction_sources().await,diff --git a/codex-rs/core/tests/suite/compact_program_tests.rs b/codex-rs/core/tests/suite/compact_program_tests.rsindex 808fffe145..67d42b69e8 100644--- a/codex-rs/core/tests/suite/compact_program_tests.rs+++ b/codex-rs/core/tests/suite/compact_program_tests.rs@@ -17,7 +17,6 @@ enum History {Fork,Rollback,IncompleteRollback,- Checkpoint,ApiKeyResume,ApiKeyEnabledResume,ApiKeyCustomProviderResume,@@ -71,7 +70,6 @@ async fn submit_pair(#[test_case(Compaction::RemoteHash, History::Fork, Some(CyberAccessProgram::DaybreakBlue); "fork")]#[test_case(Compaction::RemoteHash, History::Rollback, Some(CyberAccessProgram::DaybreakBlue); "rollback")]#[test_case(Compaction::RemoteHash, History::IncompleteRollback, Some(CyberAccessProgram::DaybreakBlue); "incomplete rollback")]-#[test_case(Compaction::RemoteHash, History::Checkpoint, Some(CyberAccessProgram::DaybreakBlue); "checkpoint")]#[test_case(Compaction::RemoteHash, History::Resume, None; "missing program")]#[test_case(Compaction::RemoteHash, History::Resume, Some(CyberAccessProgram::Standard); "standard")]#[test_case(Compaction::LocalHash, History::Live, None; "local missing program")]@@ -165,30 +163,6 @@ async fn model_switch_program_pair(discarded_model);}- if matches!(history, History::Checkpoint) {- let compact = mount_sse_once(- &server,- sse(vec![- json!({"type": "response.output_item.done", "item": {- "type": "compaction", "encrypted_content": "CHECKPOINT"- }}),- ev_completed("checkpoint"),- ]),- )- .await;- initial.codex.submit(Op::Compact).await?;- wait_for_event(&initial.codex, |event| {- matches!(event, EventMsg::TurnComplete(_))- })- .await;- assert_eq!(- compact- .single_request()- .inputs_of_type("compaction_trigger")- .len(),- 1- );- }let resumed;let thread = match history {@@ -210,7 +184,6 @@ async fn model_switch_program_pair(History::Resume| History::Rollback| History::IncompleteRollback- | History::Checkpoint| History::ApiKeyResume| History::ApiKeyEnabledResume| History::ApiKeyCustomProviderResume => {@@ -368,6 +341,39 @@ async fn model_switch_program_pair(if !local {assert_eq!(requests[0].inputs_of_type("compaction_trigger").len(), 1);}++ // Even when the previous model summarizes, the replacement belongs to the current model.+ let rollout = fs::read_to_string(thread.rollout_path().expect("rollout"))?+ .lines()+ .map(codex_rollout::parse_rollout_line)+ .collect::<Result<Vec<_>, _>>()?;+ let checkpoint = rollout+ .iter()+ .rposition(|line| matches!(&line.item, RolloutItem::Compacted(_)))+ .expect("model-switch compaction");+ let replacement = &rollout[checkpoint + 1..];+ let world_state = replacement+ .iter()+ .find_map(|line| match &line.item {+ RolloutItem::WorldState(state) => Some(state),+ _ => None,+ })+ .expect("replacement world state");+ let turn_context = replacement+ .iter()+ .find_map(|line| match &line.item {+ RolloutItem::TurnContext(context) => Some(context),+ _ => None,+ })+ .expect("replacement turn context");+ assert_eq!(+ (+ world_state.full,+ world_state.state.get("model"),+ turn_context.model.as_str(),+ ),+ (true, Some(&json!(next_model)), next_model),+ );Ok(())}diff --git a/codex-rs/core/tests/suite/compact_resume_fork.rs b/codex-rs/core/tests/suite/compact_resume_fork.rsindex 12ae3d701d..c20769beb6 100644--- a/codex-rs/core/tests/suite/compact_resume_fork.rs+++ b/codex-rs/core/tests/suite/compact_resume_fork.rs@@ -277,18 +277,16 @@ async fn compact_resume_and_fork_preserve_model_history_view() {let summary_after_compact = extract_summary_user_text(&requests[2], SUMMARY_TEXT);let summary_after_resume = extract_summary_user_text(&requests[3], SUMMARY_TEXT);let summary_after_fork = extract_summary_user_text(&requests[4], SUMMARY_TEXT);- let mut expected_after_compact_user_texts =- vec!["hello world".to_string(), summary_after_compact];- expected_after_compact_user_texts.extend_from_slice(seeded_user_prefix);+ let mut expected_after_compact_user_texts = seeded_user_prefix.to_vec();+ expected_after_compact_user_texts.extend(["hello world".to_string(), summary_after_compact]);expected_after_compact_user_texts.push("AFTER_COMPACT".to_string());assert_eq!(json_message_input_texts(&requests[2], "user"),expected_after_compact_user_texts);- let mut expected_after_resume_user_texts =- vec!["hello world".to_string(), summary_after_resume];- expected_after_resume_user_texts.extend_from_slice(seeded_user_prefix);+ let mut expected_after_resume_user_texts = seeded_user_prefix.to_vec();+ expected_after_resume_user_texts.extend(["hello world".to_string(), summary_after_resume]);expected_after_resume_user_texts.push("AFTER_COMPACT".to_string());let after_resume_user_texts = json_message_input_texts(&requests[3], "user");let (after_resume_last, after_resume_prefix) = after_resume_user_texts@@ -317,9 +315,8 @@ async fn compact_resume_and_fork_preserve_model_history_view() {}let after_fork_user_texts = json_message_input_texts(&requests[4], "user");- let mut expected_after_fork_history_prefix =- vec!["hello world".to_string(), summary_after_fork];- expected_after_fork_history_prefix.extend_from_slice(seeded_user_prefix);+ let mut expected_after_fork_history_prefix = seeded_user_prefix.to_vec();+ expected_after_fork_history_prefix.extend(["hello world".to_string(), summary_after_fork]);expected_after_fork_history_prefix.push("AFTER_COMPACT".to_string());let (after_fork_last, after_fork_prefix) = after_fork_user_texts.split_last()@@ -450,15 +447,19 @@ async fn compact_resume_after_second_compaction_preserves_history() -> Result<()"hello world".to_string(),"AFTER_COMPACT".to_string(),"AFTER_RESUME".to_string(),- "AFTER_FORK".to_string(),- summary_after_second_compact.clone(),];expected_after_second_compact_user_texts.extend_from_slice(seeded_user_prefix);- expected_after_second_compact_user_texts.push("AFTER_COMPACT_2".to_string());- let mut expected_fork_local_user_texts =- vec!["AFTER_FORK".to_string(), summary_after_second_compact];- expected_fork_local_user_texts.extend_from_slice(seeded_user_prefix);- expected_fork_local_user_texts.push("AFTER_COMPACT_2".to_string());+ expected_after_second_compact_user_texts.extend([+ "AFTER_FORK".to_string(),+ summary_after_second_compact.clone(),+ "AFTER_COMPACT_2".to_string(),+ ]);+ let mut expected_fork_local_user_texts = seeded_user_prefix.to_vec();+ expected_fork_local_user_texts.extend([+ "AFTER_FORK".to_string(),+ summary_after_second_compact,+ "AFTER_COMPACT_2".to_string(),+ ]);let final_user_texts = json_message_input_texts(&requests[requests.len() - 1], "user");let (final_last, final_prefix) = final_user_texts.split_last()diff --git a/codex-rs/core/tests/suite/skills_extension.rs b/codex-rs/core/tests/suite/skills_extension.rsindex be32ec9232..5b3bea2236 100644--- a/codex-rs/core/tests/suite/skills_extension.rs+++ b/codex-rs/core/tests/suite/skills_extension.rs@@ -3236,17 +3236,8 @@ async fn production_turn_keeps_rebalanced_catalogs_stable_after_compaction_and_r_ => None,}).expect("compaction retains an allocation checkpoint");- let allocation = checkpoint.state["cloud_skills"]["allocation"]- .as_object()- .expect("retained allocation");- assert_eq!(- serde_json::to_value(checkpoint)?,- json!({- "full": true,- "state": { "cloud_skills": { "allocation": allocation } },- }),- "compaction retains only allocation metadata, not rendered catalogs",- );+ assert!(checkpoint.full);+ assert!(checkpoint.state["cloud_skills"]["allocation"].is_object());let resumed = test.thread_manager.start_thread(StartThreadOptions {@@ -3337,7 +3328,7 @@ async fn production_turn_keeps_rebalanced_catalogs_stable_after_compaction_and_r.flat_map(|text| text.lines()).filter(|line| line.starts_with("- exec-")).collect::<Vec<_>>(),- if matches!(index, 0 | 4) {+ if index == 0 {Vec::new()} else {ready_executor_lines.clone()@@ -3358,7 +3349,7 @@ async fn production_turn_keeps_rebalanced_catalogs_stable_after_compaction_and_r"cloud_skills_across_executor_readiness"},context_snapshot::format_request_history_snapshot(- "Cloud skills rebalance once to retain every executor skill. Post-turn compaction and resume restore the same cloud allocation before the executor reconnects; both catalogs are fully reinjected once into the new history.",+ "Cloud skills rebalance once to retain every executor skill. Post-turn compaction installs both catalogs and their allocation before resume; the saved catalogs remain visible while the executor reconnects.",&requests,&ContextSnapshotOptions::default().rewrite_known_segments()diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_with_history_shapes.snap b/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_with_history_shapes.snapindex 82dbcd68b9..a62c82bf67 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_with_history_shapes.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_with_history_shapes.snap@@ -26,31 +26,31 @@ Scenario: Manual /compact with prior user history compacts existing history and04:message/user:<SUMMARIZATION_PROMPT>-## Window 3 (after request 2: input diverged at item 00, settings changed (parallel_tool_calls, tools))+## Window 3 (after request 2: input diverged at item 03, settings changed (parallel_tool_calls, tools))-- request 3 (turn) ---00:message/user:- first manual turn+00:message/developer:+ <PERMISSIONS_INSTRUCTIONS>01:message/user:+ <ENVIRONMENT_CONTEXT>+02:message/user:+ first manual turn+03:message/user:<COMPACTION_SUMMARY>FIRST_MANUAL_SUMMARY-02:message/developer:- <PERMISSIONS_INSTRUCTIONS>-03:message/user:- <ENVIRONMENT_CONTEXT>04:message/user:second manual turn## Window 4 (after request 3: settings changed (parallel_tool_calls, tools))-- request 4 (compaction) ---00:message/user:- first manual turn+00:message/developer:+ <PERMISSIONS_INSTRUCTIONS>01:message/user:+ <ENVIRONMENT_CONTEXT>+02:message/user:+ first manual turn+03:message/user:<COMPACTION_SUMMARY>FIRST_MANUAL_SUMMARY-02:message/developer:- <PERMISSIONS_INSTRUCTIONS>-03:message/user:- <ENVIRONMENT_CONTEXT>04:message/user:second manual turn05:message/assistant:@@ -58,18 +58,18 @@ Scenario: Manual /compact with prior user history compacts existing history and06:message/user:<SUMMARIZATION_PROMPT>-## Window 5 (after request 4: input diverged at item 01, settings changed (parallel_tool_calls, tools))+## Window 5 (after request 4: input diverged at item 00, settings changed (parallel_tool_calls, tools))-- request 5 (turn) --00:message/user:first manual turn-01:message/user:- second manual turn+01:message/developer:+ <PERMISSIONS_INSTRUCTIONS>02:message/user:+ <ENVIRONMENT_CONTEXT>+03:message/user:+ second manual turn+04:message/user:<COMPACTION_SUMMARY>SECOND_MANUAL_SUMMARY-03:message/developer:- <PERMISSIONS_INSTRUCTIONS>-04:message/user:- <ENVIRONMENT_CONTEXT>05:message/user:post compact follow-updiff --git a/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_without_prev_user_shapes.snap b/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_without_prev_user_shapes.snapindex 173094fbad..805b72dae8 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_without_prev_user_shapes.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__compact__manual_compact_without_prev_user_shapes.snap@@ -11,12 +11,12 @@ Scenario: Manual /compact with no prior user turn currently still issues a compa## Window 2 (after request 1: input diverged at item 00, settings changed (parallel_tool_calls, tools))-- request 2 (turn; Local Post-Compaction History Layout) ---00:message/user:- <COMPACTION_SUMMARY>- MANUAL_EMPTY_SUMMARY-01:message/developer:+00:message/developer:<PERMISSIONS_INSTRUCTIONS>-02:message/user:+01:message/user:<ENVIRONMENT_CONTEXT>+02:message/user:+ <COMPACTION_SUMMARY>+ MANUAL_EMPTY_SUMMARY03:message/user:AFTER_MANUAL_EMPTY_COMPACTdiff --git a/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_sampling_model_switch_compaction_shapes.snap b/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_sampling_model_switch_compaction_shapes.snapindex 41ce4d86b1..d20f5f5087 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_sampling_model_switch_compaction_shapes.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_sampling_model_switch_compaction_shapes.snap@@ -28,15 +28,15 @@ Scenario: Pre-sampling compaction on model switch to a smaller context window: c## Window 3 (after request 2: input diverged at item 00, settings changed (model, parallel_tool_calls, tools))-- request 3 (turn; Post-Compaction Follow-up Request (Next Model)) ---00:message/user:- before switch-01:message/user:- <COMPACTION_SUMMARY>- PRE_SAMPLING_SUMMARY-02:message/developer[2]:+00:message/developer[2]:[01] <MODEL_SWITCH>[02] <PERMISSIONS_INSTRUCTIONS>-03:message/user:+01:message/user:<ENVIRONMENT_CONTEXT>+02:message/user:+ before switch+03:message/user:+ <COMPACTION_SUMMARY>+ PRE_SAMPLING_SUMMARY04:message/user:after switchdiff --git a/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_including_incoming_shapes.snap b/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_including_incoming_shapes.snapindex b02d359089..1d92f720c1 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_including_incoming_shapes.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_including_incoming_shapes.snap@@ -39,15 +39,15 @@ Scenario: Pre-turn auto-compaction uses the prior context without the incoming u-- request 4 (turn) --00:message/user:USER_ONE-01:message/user:- USER_TWO+01:message/developer:+ <PERMISSIONS_INSTRUCTIONS>02:message/user:+ <ENVIRONMENT_CONTEXT>+03:message/user:+ USER_TWO+04:message/user:<COMPACTION_SUMMARY>PRE_TURN_SUMMARY-03:message/developer:- <PERMISSIONS_INSTRUCTIONS>-04:message/user:- <ENVIRONMENT_CONTEXT>05:message/user[2]:[01] <input_image:detail,image_url>[02] USER_THREEdiff --git a/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_strips_incoming_model_switch_shapes.snap b/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_strips_incoming_model_switch_shapes.snapindex b8c8987bac..2aed44c7f1 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_strips_incoming_model_switch_shapes.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__compact__pre_turn_compaction_strips_incoming_model_switch_shapes.snap@@ -28,15 +28,15 @@ Scenario: Pre-turn compaction during model switch (without pre-sampling model-sw## Window 3 (after request 2: input diverged at item 00, settings changed (parallel_tool_calls, tools))-- request 3 (turn; Local Post-Compaction History Layout) ---00:message/user:- BEFORE_SWITCH_USER-01:message/user:- <COMPACTION_SUMMARY>- PRETURN_SWITCH_SUMMARY-02:message/developer[2]:+00:message/developer[2]:[01] <MODEL_SWITCH>[02] <PERMISSIONS_INSTRUCTIONS>-03:message/user:+01:message/user:<ENVIRONMENT_CONTEXT>+02:message/user:+ BEFORE_SWITCH_USER+03:message/user:+ <COMPACTION_SUMMARY>+ PRETURN_SWITCH_SUMMARY04:message/user:AFTER_SWITCH_USERdiff --git a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__astra_kickoff_remote_compaction_windows.snap b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__astra_kickoff_remote_compaction_windows.snapindex 4509958edc..877c62c5bf 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__astra_kickoff_remote_compaction_windows.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__astra_kickoff_remote_compaction_windows.snap@@ -222,10 +222,7 @@ Settings: same as window 102:message/user:Plan a team kickoff for Friday using $outline and $calendar:agenda.-03:message/user:- Summarize the kickoff notes with $notes:summarize.-04:compaction:encrypted=true; chars=26; hash=ec5e2724e6f5f641-05:message/developer[3]:+03:message/developer[3]:[01] <skills_instructions>## SkillsA skill is a set of local instructions to follow that is stored in a `SKILL.md` file. Below is the list ...ed into an absolute path using the skill roots table. [hash=ca27c3957f42502b]@@ -271,7 +268,7 @@ Settings: same as window 1Never use the `request_user_input` tool for permission requests or permission-related escalations.</collaboration_mode>-06:message/developer:+04:message/developer:<multi_agent_role>You are `/root`, the primary agent in a team of agents collaborating to fulfill the user's goals.At the start of your turn, you are the active agent.@@ -289,9 +286,9 @@ Settings: same as window 1There are 4 available concurrency slots, meaning that up to 4 agents can be active at once, including you.Full-history forks (`fork_turns` omitted or `"all"`) inherit the parent model and reasoning effort and d...ne"` or a positive integer string.</multi_agent_role> [hash=c7f52e90688299ce]-07:message/developer:+05:message/developer:<multi_agent_mode>Any earlier instruction enabling proactive multi-agent delegation no longer applies. D...elegation, or parallel agent work.</multi_agent_mode> [hash=2b6e037067b4390c]-08:message/user[2]:+06:message/user[2]:[01] # AGENTS.md instructions for <AGENTS_DIRECTORY><INSTRUCTIONS>@@ -304,6 +301,9 @@ Settings: same as window 1<timezone><HOST_TIMEZONE></timezone><filesystem><workspace_roots><root><WORKSPACE_ROOT 1></root></workspace_roots><permission_profile type...ntry></file_system></permission_profile></filesystem> [hash=911722cc43b4c3b8]</environment_context>+07:message/user:+ Summarize the kickoff notes with $notes:summarize.+08:compaction:encrypted=true; chars=26; hash=ec5e2724e6f5f64109:message/user[2]:[01] Check the final kickoff brief and attached sketch with $final-check and $calendar:agenda.[02] <input_image:image_url>diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__compaction__remote_slash_compact.snap b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__compaction__remote_slash_compact.snapindex ab2bf0b330..00d8b90f33 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__compaction__remote_slash_compact.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__compaction__remote_slash_compact.snap@@ -108,9 +108,58 @@ Settings:## Window 2 (after request 2: input diverged at item 00)Settings: unavailable (items only)-- request 3 (items; Stored replacement before next turn) ---00:message/user:+00:message/developer[2]:+ [01] <permissions instructions>+ Filesystem sandboxing defines which files can be read or written. `sandbox_mode` is `danger-full-access`...ll commands are permitted. Network access is enabled. [hash=c134061cebb94a1b]+ Approval policy is currently never. Do not provide the `sandbox_permissions` for any reason, commands will be rejected.+ </permissions instructions>+ [02] <collaboration_mode># Collaboration Mode: Default++ You are now in Default mode. Any previous instructions for other modes (e.g. Plan mode) are no longer active.++ Your active mode changes only when new developer instructions with a different `<collaboration_mode>...<...by themselves. Known mode names are Default and Plan. [hash=e75f6b12fc52d812]++ ## request_user_input availability++ Use the `request_user_input` tool only when it is listed in the available tools for this turn.++ Use the `request_user_input` tool only for optional questions where the answer would materially improve the quality of the work.++ If `request_user_input` returns no answers, continue with best judgment instead of asking again or treating the turn as blocked.++ Never use the `request_user_input` tool for permission requests or permission-related escalations.+ </collaboration_mode>+01:message/developer:+ <multi_agent_role>You are `/root`, the primary agent in a team of agents collaborating to fulfill the user's goals.++ At the start of your turn, you are the active agent.+ You can spawn sub-agents to handle subtasks, and those sub-agents can spawn their own sub-agents.+ All agents in the team, including the agents that you can assign tasks to, are equally intelligent and capable, and have access to the same set of tools.++ You can use `spawn_agent` to create a new agent, `followup_task` to give an existing agent a new task an...message to a running agent without triggering a turn. [hash=7d40ff8b58977202]+ `send_message` calls may be read by a human, so ensure they are legible. Always put proper spaces between words and/or numbers.+ <OMITTED 17 LINES; ~246 TOKENS; hash=780031e2df907944>+ - All agents use the same current working directory.+ - As a result, edits made by one agent are immediately visible to all other agents.++ When calling `wait_agent`, prefer longer waits (minutes) to avoid busy polling.++ There are 4 available concurrency slots, meaning that up to 4 agents can be active at once, including you.++ Full-history forks (`fork_turns` omitted or `"all"`) inherit the parent model and reasoning effort and d...ne"` or a positive integer string.</multi_agent_role> [hash=c7f52e90688299ce]+02:message/developer:+ <multi_agent_mode>Any earlier instruction enabling proactive multi-agent delegation no longer applies. D...elegation, or parallel agent work.</multi_agent_mode> [hash=2b6e037067b4390c]+03:message/user:+ <environment_context>+ <cwd><CWD></cwd>+ <shell><HOST_SHELL></shell>+ <current_date><CURRENT_DATE></current_date>+ <timezone><HOST_TIMEZONE></timezone>+ <filesystem><workspace_roots><root><CWD></root></workspace_roots><permission_profile type="disabled"><...e="unrestricted" /></permission_profile></filesystem> [hash=d40b2f45cb028888]+ </environment_context>+04:message/user:Plan the release.-01:compaction:encrypted=true; chars=31; hash=8255caf138edede8+05:compaction:encrypted=true; chars=31; hash=8255caf138edede8## Window 3 (after request 3: input diverged at item 00)Settings: same as window 1@@ -148,10 +197,7 @@ Settings: same as window 1- Relevance: Determine what a plugin can help with from explicit user mention or from the plugin-associa..., MCP tools, and apps exposed elsewhere in this turn. [hash=620459a4e7b590f0]- Missing/blocked: If the user requests a plugin that does not have relevant callable capabilities for t..., say so briefly and continue with the best fallback. [hash=746b0469a8f6cb3e]-02:message/user:- Plan the release.-03:compaction:encrypted=true; chars=31; hash=8255caf138edede8-04:message/developer[2]:+02:message/developer[2]:[01] <permissions instructions>Filesystem sandboxing defines which files can be read or written. `sandbox_mode` is `danger-full-access`...ll commands are permitted. Network access is enabled. [hash=c134061cebb94a1b]Approval policy is currently never. Do not provide the `sandbox_permissions` for any reason, commands will be rejected.@@ -172,7 +218,7 @@ Settings: same as window 1Never use the `request_user_input` tool for permission requests or permission-related escalations.</collaboration_mode>-05:message/developer:+03:message/developer:<multi_agent_role>You are `/root`, the primary agent in a team of agents collaborating to fulfill the user's goals.At the start of your turn, you are the active agent.@@ -190,9 +236,9 @@ Settings: same as window 1There are 4 available concurrency slots, meaning that up to 4 agents can be active at once, including you.Full-history forks (`fork_turns` omitted or `"all"`) inherit the parent model and reasoning effort and d...ne"` or a positive integer string.</multi_agent_role> [hash=c7f52e90688299ce]-06:message/developer:+04:message/developer:<multi_agent_mode>Any earlier instruction enabling proactive multi-agent delegation no longer applies. D...elegation, or parallel agent work.</multi_agent_mode> [hash=2b6e037067b4390c]-07:message/user:+05:message/user:<environment_context><cwd><CWD></cwd><shell><HOST_SHELL></shell>@@ -200,5 +246,8 @@ Settings: same as window 1<timezone><HOST_TIMEZONE></timezone><filesystem><workspace_roots><root><CWD></root></workspace_roots><permission_profile type="disabled"><...e="unrestricted" /></permission_profile></filesystem> [hash=d40b2f45cb028888]</environment_context>+06:message/user:+ Plan the release.+07:compaction:encrypted=true; chars=31; hash=8255caf138edede808:message/user:Continue with the first step.diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__guardian_checkpoint_migration.snap b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__guardian_checkpoint_migration.snapindex fcf9b869e4..4cbd316078 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__guardian_checkpoint_migration.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__guardian_checkpoint_migration.snap@@ -59,14 +59,14 @@ Settings: relative to window 1<MODEL_INSTRUCTIONS>02:message/user:Keep the working tree unchanged.-03:message/user:- Confirm where publishing is allowed.-04:compaction:encrypted=true; chars=39; hash=4010be12538dbedf-05:message/developer[2]:+03:message/developer[2]:[01] <MODEL_SWITCH>[02] <PERMISSIONS_INSTRUCTIONS>-06:message/user:+04:message/user:<ENVIRONMENT_CONTEXT>+05:message/user:+ Confirm where publishing is allowed.+06:compaction:encrypted=true; chars=39; hash=4010be12538dbedf07:message/user:Continue with the new model.-- request 5 (turn) --@@ -196,14 +196,14 @@ Settings: same as window 2<MODEL_INSTRUCTIONS>02:message/user:Keep the working tree unchanged.-03:message/user:- Confirm where publishing is allowed.-04:compaction:encrypted=true; chars=39; hash=4010be12538dbedf-05:message/developer[2]:+03:message/developer[2]:[01] <MODEL_SWITCH>[02] <PERMISSIONS_INSTRUCTIONS>-06:message/user:+04:message/user:<ENVIRONMENT_CONTEXT>+05:message/user:+ Confirm where publishing is allowed.+06:compaction:encrypted=true; chars=39; hash=4010be12538dbedf07:message/user:Continue with the new model.08:message/user:@@ -213,7 +213,7 @@ Settings: same as window 2-- request 8 (compaction) --11:compaction_trigger-## Window 5 (after request 8: input diverged at item 04)+## Window 5 (after request 8: input diverged at item 03)Settings: same as window 2-- request 9 (turn) --00:additional_tools/developer (1; hash=1ea3c73f7e3c8b33):@@ -229,13 +229,13 @@ Settings: same as window 2Confirm where publishing is allowed.04:message/user:Continue with the new model.-05:message/user:- Run another check after compaction.-06:compaction:encrypted=true; chars=33; hash=5c07b4383c427607-07:message/developer:+05:message/developer:<PERMISSIONS_INSTRUCTIONS>-08:message/user:+06:message/user:<ENVIRONMENT_CONTEXT>+07:message/user:+ Run another check after compaction.+08:compaction:encrypted=true; chars=33; hash=5c07b4383c42760709:message/user:Run another check after compaction.@@ -353,13 +353,13 @@ Settings: same as window 2Confirm where publishing is allowed.04:message/user:Continue with the new model.-05:message/user:- Run another check after compaction.-06:compaction:encrypted=true; chars=33; hash=5c07b4383c427607-07:message/developer:+05:message/developer:<PERMISSIONS_INSTRUCTIONS>-08:message/user:+06:message/user:<ENVIRONMENT_CONTEXT>+07:message/user:+ Run another check after compaction.+08:compaction:encrypted=true; chars=33; hash=5c07b4383c42760709:message/user:Run another check after compaction.10:function_call/exec_command:{"cmd":"exit 0","sandbox_permissions":"require_escalated"}diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness.snap b/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness.snapindex 40d24ce51c..5dc7e7d935 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness.snap@@ -1,8 +1,8 @@---source: core/tests/suite/skills_extension.rs-expression: "context_snapshot::format_request_history_snapshot(\"Cloud skills rebalance once to retain every executor skill. Post-turn compaction and resume restore the same cloud allocation before the executor reconnects; both catalogs are fully reinjected once into the new history.\",\n&requests,\n&ContextSnapshotOptions::default().rewrite_known_segments().include_request_settings(),)"+expression: "context_snapshot::format_request_history_snapshot(\"Cloud skills rebalance once to retain every executor skill. Post-turn compaction installs both catalogs and their allocation before resume; the saved catalogs remain visible while the executor reconnects.\",\n&requests,\n&ContextSnapshotOptions::default().rewrite_known_segments().include_request_settings(),)"----Scenario: Cloud skills rebalance once to retain every executor skill. Post-turn compaction and resume restore the same cloud allocation before the executor reconnects; both catalogs are fully reinjected once into the new history.+Scenario: Cloud skills rebalance once to retain every executor skill. Post-turn compaction installs both catalogs and their allocation before resume; the saved catalogs remain visible while the executor reconnects.## Window 1Settings:@@ -102,12 +102,7 @@ Settings: same as window 1-- request 5 (turn) --00:message/user:Inspect the available skills.-01:message/user:- Inspect the available skills again.-02:message/user:- <COMPACTION_SUMMARY>- The available skills were inspected.-03:message/developer[3]:+01:message/developer[4]:[01] <PERMISSIONS_INSTRUCTIONS>[02] <environments_instructions>## Execution environments@@ -118,14 +113,24 @@ Settings: same as window 1Wait only when the current task needs that environment. Continue using tools that are already available for unrelated work.</environments_instructions>[03] <SKILLS_INSTRUCTIONS>-04:message/user:+ [04] <SKILLS_INSTRUCTIONS>+02:message/user:<ENVIRONMENT_CONTEXT>+03:message/user:+ Inspect the available skills again.+04:message/user:+ <COMPACTION_SUMMARY>+ The available skills were inspected.05:message/user:+ <ENVIRONMENT_CONTEXT>+06:message/developer:+ <SKILLS_INSTRUCTIONS>+07:message/user:Inspect the skills after resuming.-- request 6 (turn) ---06:function_call/wait_for_environment:{"environment_id":"skills-executor"}-07:function_call_output:{"environment_id":"skills-executor","status":"ready"}-08:message/user:+08:function_call/wait_for_environment:{"environment_id":"skills-executor"}+09:function_call_output:{"environment_id":"skills-executor","status":"ready"}+10:message/user:<ENVIRONMENT_CONTEXT>-09:message/developer:+11:message/developer:<SKILLS_INSTRUCTIONS>diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness_windows.snap b/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness_windows.snapindex 980a174b01..6a0f17c4e2 100644--- a/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness_windows.snap+++ b/codex-rs/core/tests/suite/snapshots/all__suite__skills_extension__cloud_skills_across_executor_readiness_windows.snap@@ -1,8 +1,8 @@---source: core/tests/suite/skills_extension.rs-expression: "context_snapshot::format_request_history_snapshot(\"Cloud skills rebalance once to retain every executor skill. Post-turn compaction and resume restore the same cloud allocation before the executor reconnects; both catalogs are fully reinjected once into the new history.\",\n&requests,\n&ContextSnapshotOptions::default().rewrite_known_segments().include_request_settings(),)"+expression: "context_snapshot::format_request_history_snapshot(\"Cloud skills rebalance once to retain every executor skill. Post-turn compaction installs both catalogs and their allocation before resume; the saved catalogs remain visible while the executor reconnects.\",\n&requests,\n&ContextSnapshotOptions::default().rewrite_known_segments().include_request_settings(),)"----Scenario: Cloud skills rebalance once to retain every executor skill. Post-turn compaction and resume restore the same cloud allocation before the executor reconnects; both catalogs are fully reinjected once into the new history.+Scenario: Cloud skills rebalance once to retain every executor skill. Post-turn compaction installs both catalogs and their allocation before resume; the saved catalogs remain visible while the executor reconnects.## Window 1Settings:@@ -122,12 +122,7 @@ Settings: same as window 1-- request 5 (turn) --00:message/user:Inspect the available skills.-01:message/user:- Inspect the available skills again.-02:message/user:- <COMPACTION_SUMMARY>- The available skills were inspected.-03:message/developer[3]:+01:message/developer[4]:[01] <PERMISSIONS_INSTRUCTIONS>[02] <environments_instructions>## Execution environments@@ -138,9 +133,19 @@ Settings: same as window 1Wait only when the current task needs that environment. Continue using tools that are already available for unrelated work.</environments_instructions>[03] <SKILLS_INSTRUCTIONS>-04:message/user:+ [04] <SKILLS_INSTRUCTIONS>+02:message/user:<ENVIRONMENT_CONTEXT>+03:message/user:+ Inspect the available skills again.+04:message/user:+ <COMPACTION_SUMMARY>+ The available skills were inspected.05:message/user:+ <ENVIRONMENT_CONTEXT>+06:message/developer:+ <SKILLS_INSTRUCTIONS>+07:message/user:Inspect the skills after resuming.## Window 5 (after request 5)@@ -148,12 +153,7 @@ Settings: same as window 2-- request 6 (turn) --00:message/user:Inspect the available skills.-01:message/user:- Inspect the available skills again.-02:message/user:- <COMPACTION_SUMMARY>- The available skills were inspected.-03:message/developer[3]:+01:message/developer[4]:[01] <PERMISSIONS_INSTRUCTIONS>[02] <environments_instructions>## Execution environments@@ -164,13 +164,23 @@ Settings: same as window 2Wait only when the current task needs that environment. Continue using tools that are already available for unrelated work.</environments_instructions>[03] <SKILLS_INSTRUCTIONS>-04:message/user:+ [04] <SKILLS_INSTRUCTIONS>+02:message/user:<ENVIRONMENT_CONTEXT>+03:message/user:+ Inspect the available skills again.+04:message/user:+ <COMPACTION_SUMMARY>+ The available skills were inspected.05:message/user:+ <ENVIRONMENT_CONTEXT>+06:message/developer:+ <SKILLS_INSTRUCTIONS>+07:message/user:Inspect the skills after resuming.-06:function_call/wait_for_environment:{"environment_id":"skills-executor"}-07:function_call_output:{"environment_id":"skills-executor","status":"ready"}-08:message/user:+08:function_call/wait_for_environment:{"environment_id":"skills-executor"}+09:function_call_output:{"environment_id":"skills-executor","status":"ready"}+10:message/user:<ENVIRONMENT_CONTEXT>-09:message/developer:+11:message/developer:<SKILLS_INSTRUCTIONS>diff --git a/codex-rs/ext/extension-api/src/contributors.rs b/codex-rs/ext/extension-api/src/contributors.rsindex 09892600d7..61cdbe4da7 100644--- a/codex-rs/ext/extension-api/src/contributors.rs+++ b/codex-rs/ext/extension-api/src/contributors.rs@@ -142,18 +142,6 @@ pub trait ContextContributor: Send + Sync {Vec::new()})}-- /// Retains bounded extension metadata when compaction discards rendered context.- ///- /// Return only this contributor's section IDs, without rendered text or availability- /// state. Core persists these partial sections so the next step can rebuild full- /// context without losing decisions that are independent of model-visible history.- fn retain_world_state_after_compaction(- &self,- _previous_world_state: &serde_json::Map<String, serde_json::Value>,- ) -> serde_json::Map<String, serde_json::Value> {- serde_json::Map::new()- }}/// Contributor for host-owned thread lifecycle gates.diff --git a/codex-rs/ext/skills/src/extension.rs b/codex-rs/ext/skills/src/extension.rsindex 4b6568045d..9a1c1cc19c 100644--- a/codex-rs/ext/skills/src/extension.rs+++ b/codex-rs/ext/skills/src/extension.rs@@ -71,7 +71,6 @@ use crate::tools::SkillAnalytics;use crate::tools::SkillToolAuthority;use crate::tools::skill_tools;use crate::warnings::bounded_warnings;-use crate::world_state::CLOUD_SKILLS_WORLD_STATE_ID;use crate::world_state_catalogs::CatalogContext;use crate::world_state_catalogs::CatalogStatus;@@ -265,25 +264,6 @@ where.collect()})}-- fn retain_world_state_after_compaction(- &self,- previous_world_state: &serde_json::Map<String, serde_json::Value>,- ) -> serde_json::Map<String, serde_json::Value> {- let mut retained = serde_json::Map::new();- if let Some(allocation) = previous_world_state- .get(CLOUD_SKILLS_WORLD_STATE_ID)- .and_then(|section| section.get("allocation"))- {- // Allocation survives lost history; the catalog fingerprint and budget still- // determine whether it can be reused after fresh discovery and policy resolution.- retained.insert(- CLOUD_SKILLS_WORLD_STATE_ID.to_string(),- serde_json::json!({ "allocation": allocation }),- );- }- retained- }}impl<C> ToolContributor for SkillsExtension<C>