Lightweight coding agent that runs in your terminal
Rust
Retain inherited Guardian instructions in standalone forks (#43478)
felixxia-oai16ff14c26617
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zstindex 10d00f3a35..08ebc8e755 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differdiff --git a/codex-rs/core/src/agent/control/user_authorization.rs b/codex-rs/core/src/agent/control/user_authorization.rsindex 71ae6176d5..cec448fecc 100644--- a/codex-rs/core/src/agent/control/user_authorization.rs+++ b/codex-rs/core/src/agent/control/user_authorization.rs@@ -61,12 +61,6 @@ impl AgentControl {root_history.annotated_items().iter()- .filter(|envelope| {- !envelope- .metadata- .as_ref()- .is_some_and(|metadata| metadata.inherited_user_message)- }).filter_map(|envelope| {let item = &envelope.item;let Some(TurnItem::UserMessage(message)) = parse_turn_item(item) else {@@ -81,6 +75,7 @@ impl AgentControl {let order = envelope.metadata.as_ref()+ .filter(|metadata| !metadata.inherited_user_message).and_then(|metadata| metadata.user_input_order);Some((order,diff --git a/codex-rs/core/src/context_manager/history.rs b/codex-rs/core/src/context_manager/history.rsindex 157c79f12d..ee077e315a 100644--- a/codex-rs/core/src/context_manager/history.rs+++ b/codex-rs/core/src/context_manager/history.rs@@ -4,6 +4,9 @@//! Oversized instructions keep an incomplete excerpt for bounded root review, including//! sources recovered from legacy Guardian checkpoints before their raw history is dropped.+#[path = "history_user_authorization.rs"]+mod user_authorization;+use crate::context::ContextualUserFragment;use crate::context::ModelSwitchInstructions;use crate::context::world_state::PersistentModeState;@@ -30,6 +33,7 @@ use codex_history::GuardianHistoryCheckpoint;use codex_history::ResponseItemEnvelope;use codex_history::RetainedContext;use codex_history::RetainedContextEvent;+use codex_history::RetainedInputSource;use codex_protocol::items::TurnItem;use codex_protocol::models::AgentMessageInputContent;use codex_protocol::models::BaseInstructions;@@ -40,6 +44,7 @@ use codex_protocol::models::ImageDetail;use codex_protocol::models::ResponseItem;use codex_protocol::openai_models::InputModality;use codex_protocol::protocol::InterAgentCommunication;+use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::TokenUsage;use codex_protocol::protocol::TokenUsageInfo;use codex_protocol::protocol::TurnContextItem;@@ -71,6 +76,7 @@ pub(crate) struct ContextManager {retained_context: Arc<RetainedContext>,/// Capture, replay, and snapshot selection share the immutable session mode.guardian_context_mode: GuardianContextMode,+ retain_inherited_user_messages: bool,/// Bumped whenever history is rewritten, such as compaction or rollback.history_version: u64,/// Monotonic user-input/reset revision, independent of compaction's history generation.@@ -169,6 +175,7 @@ impl ContextManager {review_history: None,retained_context: Arc::default(),guardian_context_mode: GuardianContextMode::Legacy,+ retain_inherited_user_messages: false,history_version: 0,user_message_revision: 0,token_info: TokenUsageInfo::new_or_append(@@ -194,9 +201,15 @@ impl ContextManager {&self.retained_context}- pub(crate) fn with_guardian_context_mode(guardian_context_mode: GuardianContextMode) -> Self {+ pub(crate) fn with_guardian_context_mode(+ guardian_context_mode: GuardianContextMode,+ source: &SessionSource,+ ) -> Self {Self {guardian_context_mode,+ retain_inherited_user_messages: guardian_context_mode+ == GuardianContextMode::ThreadOwned+ && !source.is_non_root_agent(),..Self::new()}}@@ -213,10 +226,6 @@ impl ContextManager {true}- pub(crate) fn restore_retained_context(&mut self, checkpoint: Option<&RetainedContext>) {- Arc::make_mut(&mut self.retained_context).restore(checkpoint, &self.items);- }-pub(crate) fn guardian_history_checkpoint(&self) -> Option<GuardianHistoryCheckpoint> {if self.guardian_context_mode == GuardianContextMode::ThreadOwned {return None;@@ -369,54 +378,11 @@ impl ContextManager {review_history.record(&processed.item);}Arc::make_mut(&mut self.items).push(processed);- if crate::context::is_user_authorization_message(item) {- if self.guardian_context_mode == GuardianContextMode::Legacy {- Arc::make_mut(&mut self.retained_context).mark_user_messages_incomplete();- } else if !metadata.is_some_and(|metadata| metadata.inherited_user_message)- && let ResponseItem::Message {- content,- internal_chat_message_metadata_passthrough,- ..- } = item- {- let mut complete = internal_chat_message_metadata_passthrough- .as_ref()- .and_then(|metadata| metadata.content_item_kinds.as_ref())- .is_some_and(|kinds| {- kinds.len() == content.len()- && kinds.iter().all(|kind| kind.0.starts_with("user."))- });- let text = content- .iter()- .filter_map(|content| match content {- ContentItem::InputText { text } | ContentItem::OutputText { text } => {- Some(text.as_str())- }- _ => {- complete = false;- None- }- })- .collect::<Vec<_>>()- .join("\n");- // Keep the same bounded text that child reviewers receive before- // compaction, instead of letting storage discard a large source.- // Local instruction sections still omit incomplete originals whole.- let (text, truncated) =- guardian_truncate_text(&text, GUARDIAN_MAX_ROOT_MESSAGE_TOKENS);- complete &= !truncated;- Arc::make_mut(&mut self.retained_context).record_user_message(- codex_history::RetainedUserMessage {- turn_id: item.turn_id().unwrap_or_default().to_owned(),- message_id: item.id().map(|id| id.as_str().to_owned()),- text,- complete,- },- metadata.and_then(|metadata| metadata.user_input_order),- );- }- self.user_message_revision = self.user_message_revision.saturating_add(1);- }+ self.record_user_authorization(+ item,+ metadata,+ user_authorization::UserMessageSource::Original,+ );}}@@ -590,10 +556,7 @@ impl ContextManager {let first_removed_message_id = snapshot[cut_idx].id().map(codex_protocol::ResponseItemId::as_str);- let acceptance_order = snapshot[cut_idx]- .metadata- .as_ref()- .and_then(|metadata| metadata.user_input_order);+ let source = RetainedInputSource::from(snapshot[cut_idx].metadata.as_ref());let mut review_history = self.review_history.take();if let Some(history) = &mut review_history {history.truncate_before(&snapshot[cut_idx].item);@@ -638,7 +601,7 @@ impl ContextManager {Arc::make_mut(&mut retained_context).rollback(&removed_turns,first_removed_message_id,- acceptance_order,+ source,);} else {Arc::make_mut(&mut retained_context).retain_answers(|answer| {diff --git a/codex-rs/core/src/context_manager/history_tests.rs b/codex-rs/core/src/context_manager/history_tests.rsindex f634b0049e..bfbe5d162b 100644--- a/codex-rs/core/src/context_manager/history_tests.rs+++ b/codex-rs/core/src/context_manager/history_tests.rs@@ -1269,7 +1269,10 @@ fn drop_last_n_user_turns_preserves_prefix() {// A steered message shares its source turn, but rollback must keep the earlier// instruction and answer as complete evidence, including after the next compaction.- let mut history = ContextManager::with_guardian_context_mode(GuardianContextMode::ThreadOwned);+ let mut history = ContextManager::with_guardian_context_mode(+ GuardianContextMode::ThreadOwned,+ &codex_protocol::protocol::SessionSource::Exec,+ );let mut expected = None;for (id, text) in [("restriction", "Never publish publicly."),diff --git a/codex-rs/core/src/context_manager/history_user_authorization.rs b/codex-rs/core/src/context_manager/history_user_authorization.rsnew file mode 100644index 0000000000..a3de08dd0f--- /dev/null+++ b/codex-rs/core/src/context_manager/history_user_authorization.rs@@ -0,0 +1,105 @@+//! Captures local authorization and adopts copied instructions when a worker becomes a root.+//! Inherited history remains excluded for workers; roots also recover it from checkpoints.+//! Oversized originals retain bounded, incomplete excerpts for root review.+//! Checkpoint copies cannot establish original completeness, even when their text is short.++use std::sync::Arc;++use super::ContextManager;+use crate::context::GuardianContextMode;+use crate::guardian::GUARDIAN_MAX_ROOT_MESSAGE_TOKENS;+use crate::guardian::guardian_truncate_text;+use codex_history::CodexHarnessMetadata;+use codex_history::RetainedContext;+use codex_history::RetainedUserMessage;+use codex_protocol::models::ContentItem;+use codex_protocol::models::ResponseItem;++/// Checkpoint items may have been shortened while preserving their original metadata.+pub(super) enum UserMessageSource {+ Original,+ Checkpoint,+}++impl ContextManager {+ pub(crate) fn restore_retained_context(&mut self, checkpoint: Option<&RetainedContext>) {+ Arc::make_mut(&mut self.retained_context).restore(checkpoint, &self.items);+ if self.retain_inherited_user_messages+ && !self.retained_context.has_inherited_user_messages()+ {+ // Worker checkpoints intentionally omit copied instructions. A standalone+ // root adopts the surviving prefix without duplicating an adopted checkpoint.+ let items = Arc::clone(&self.items);+ for envelope in items.iter().filter(|envelope| {+ envelope+ .metadata+ .as_ref()+ .is_some_and(|metadata| metadata.inherited_user_message)+ }) {+ self.record_user_authorization(+ &envelope.item,+ envelope.metadata.as_ref(),+ UserMessageSource::Checkpoint,+ );+ }+ }+ }++ pub(super) fn record_user_authorization(+ &mut self,+ item: &ResponseItem,+ metadata: Option<&CodexHarnessMetadata>,+ source: UserMessageSource,+ ) {+ if !crate::context::is_user_authorization_message(item) {+ return;+ }+ let inherited = metadata.is_some_and(|metadata| metadata.inherited_user_message);+ if self.guardian_context_mode == GuardianContextMode::Legacy {+ Arc::make_mut(&mut self.retained_context).mark_user_messages_incomplete();+ } else if (!inherited || self.retain_inherited_user_messages)+ && let ResponseItem::Message {+ content,+ internal_chat_message_metadata_passthrough,+ ..+ } = item+ {+ let mut complete = matches!(source, UserMessageSource::Original)+ && internal_chat_message_metadata_passthrough+ .as_ref()+ .and_then(|metadata| metadata.content_item_kinds.as_ref())+ .is_some_and(|kinds| {+ kinds.len() == content.len()+ && kinds.iter().all(|kind| kind.0.starts_with("user."))+ });+ let text = content+ .iter()+ .filter_map(|content| match content {+ ContentItem::InputText { text } | ContentItem::OutputText { text } => {+ Some(text.as_str())+ }+ _ => {+ complete = false;+ None+ }+ })+ .collect::<Vec<_>>()+ .join("\n");+ // Keep the same bounded text that child reviewers receive before+ // compaction, instead of letting storage discard a large source.+ // Local instruction sections still omit incomplete originals whole.+ let (text, truncated) = guardian_truncate_text(&text, GUARDIAN_MAX_ROOT_MESSAGE_TOKENS);+ complete &= !truncated;+ Arc::make_mut(&mut self.retained_context).record_user_message(+ RetainedUserMessage {+ turn_id: item.turn_id().unwrap_or_default().to_owned(),+ message_id: item.id().map(|id| id.as_str().to_owned()),+ text,+ complete,+ },+ metadata.into(),+ );+ }+ self.user_message_revision = self.user_message_revision.saturating_add(1);+ }+}diff --git a/codex-rs/core/src/session/rollout_reconstruction.rs b/codex-rs/core/src/session/rollout_reconstruction.rsindex 4ee1497ba1..38ca95c8ee 100644--- a/codex-rs/core/src/session/rollout_reconstruction.rs+++ b/codex-rs/core/src/session/rollout_reconstruction.rs@@ -339,7 +339,10 @@ impl Session {).unwrap_or(u64::MAX);- let mut history = ContextManager::with_guardian_context_mode(self.guardian_context_mode);+ let mut history = ContextManager::with_guardian_context_mode(+ self.guardian_context_mode,+ &turn_context.session_source,+ );let mut saw_legacy_compaction_without_replacement_history = false;if let Some(checkpoint) = base_compaction&& let Some(items) = &checkpoint.compacted.replacement_historydiff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex b283528024..a3e6b17a2c 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -1267,7 +1267,10 @@ impl Session {let mut state = SessionState::new_with_auto_compact_window_ids(session_configuration.clone(),initial_auto_compact_window_ids,- guardian_context_mode,+ ContextManager::with_guardian_context_mode(+ guardian_context_mode,+ &session_configuration.session_source,+ ),);state.base_instructions_provenance = base_instructions_provenance.clone();let managed_network_requirements_configured = configdiff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 9e4f5992c3..116e450033 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -8786,9 +8786,10 @@ where);let mut state = SessionState::new(session_configuration.clone());- state.history = ContextManager::with_guardian_context_mode(GuardianContextMode::from_features(- &config.features,- ));+ state.history = ContextManager::with_guardian_context_mode(+ GuardianContextMode::from_features(&config.features),+ &session_configuration.session_source,+ );let (environment_manager, resolved_turn_environments) =resolved_environments_for_configuration(&session_configuration, &default_environments).await;diff --git a/codex-rs/core/src/state/session.rs b/codex-rs/core/src/state/session.rsindex d4d04d37aa..5333661a6f 100644--- a/codex-rs/core/src/state/session.rs+++ b/codex-rs/core/src/state/session.rs@@ -12,7 +12,6 @@ use super::AdditionalContextStore;use super::auto_compact_window::AutoCompactWindow;use super::auto_compact_window::AutoCompactWindowIds;use super::auto_compact_window::AutoCompactWindowSnapshot;-use crate::context::GuardianContextMode;use crate::context_manager::ContextManager;use crate::context_manager::HistoryReplacement;use crate::session::PreviousTurnSettings;@@ -65,16 +64,15 @@ impl SessionState {Self::new_with_auto_compact_window_ids(session_configuration,AutoCompactWindowIds::new_initial(),- GuardianContextMode::Legacy,+ ContextManager::new(),)}pub(crate) fn new_with_auto_compact_window_ids(session_configuration: SessionConfiguration,auto_compact_window_ids: AutoCompactWindowIds,- guardian_context_mode: GuardianContextMode,+ history: ContextManager,) -> Self {- let history = ContextManager::with_guardian_context_mode(guardian_context_mode);Self {session_configuration,base_instructions_provenance: None,diff --git a/codex-rs/core/tests/suite/guardian_retained_context.rs b/codex-rs/core/tests/suite/guardian_retained_context.rsindex 9b4e632d34..f1079403a5 100644--- a/codex-rs/core/tests/suite/guardian_retained_context.rs+++ b/codex-rs/core/tests/suite/guardian_retained_context.rs@@ -9,6 +9,7 @@ use std::time::Duration;use anyhow::Context;use anyhow::Result;use codex_core::CodexThread;+use codex_core::ForkSnapshot;use codex_core::TurnInputRequest;use codex_core::config::Config;use codex_core::config::ThreadStoreConfig;@@ -35,7 +36,9 @@ use codex_protocol::protocol::ThreadHistoryMode;use codex_protocol::request_user_input::RequestUserInputAnswer;use codex_protocol::request_user_input::RequestUserInputResponse;use codex_protocol::user_input::UserInput;+use codex_thread_store::ForkBoundary;use codex_thread_store::LoadThreadHistoryParams;+use codex_thread_store::PrepareForkParams;use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;use core_test_support::responses::ev_function_call;@@ -893,6 +896,225 @@ enum LifecycleBoundary {ChildFork,}+// Cover live copied history and a truncated referenced checkpoint. Parent-answer+// omission is already exercised by retained_answers_cross_real_session_boundaries.+#[test_case(ThreadHistoryMode::Legacy; "copied worker history")]+#[test_case(ThreadHistoryMode::Paginated; "referenced truncated checkpoint")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn standalone_fork_retains_inherited_user_instructions(+ history_mode: ThreadHistoryMode,+) -> Result<()> {+ let compacted = history_mode == ThreadHistoryMode::Paginated;+ skip_if_no_network!(Ok(()));+ let server = start_mock_server().await;+ let mut test = test_codex()+ .with_history_mode(history_mode)+ .with_config(|config| {+ config.experimental_thread_store = ThreadStoreConfig::Local;+ config+ .features+ .disable(Feature::TokenBudget)+ .expect("use local compaction for worker checkpoint");+ config.model_provider.name = "Local compaction test provider".to_owned();+ for feature in [+ Feature::GuardianApproval,+ Feature::GuardianThreadContext,+ Feature::Collab,+ Feature::MultiAgentV2,+ Feature::DefaultModeRequestUserInput,+ ] {+ config+ .features+ .enable(feature)+ .expect("enable test feature");+ }+ })+ .build_with_auto_env(&server)+ .await?;+ let instruction = if compacted {+ format!(+ "You may publish the release. {} Delegate an inspection.",+ "Original project detail. ".repeat(500)+ )+ } else {+ "You may publish the release. Delegate an inspection.".to_owned()+ };+ let mut created = test.thread_manager.subscribe_thread_created();+ mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_function_call_with_namespace(+ "spawn", "collaboration", "spawn_agent",+ &json!({"task_name": "worker", "message": "Inspect the project.", "fork_turns": "all"}).to_string(),+ ),+ ev_completed("spawn-response"),+ ]),+ sse(vec![ev_completed("root-complete")]),+ sse(vec![ev_completed("worker-complete")]),+ ],+ ).await;+ test.codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: instruction.clone(),+ text_elements: Vec::new(),+ }]))+ .await?;+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ let worker = test+ .thread_manager+ .get_thread(created.recv().await?)+ .await?;+ wait_for_event(&worker, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ test.codex.shutdown_and_wait().await?;+ let local_instruction = if compacted {+ // Leave less than Guardian's 900-token budget for the inherited source+ // within local compaction's 20K user-message budget.+ format!("Ask me before publishing. {}", "x".repeat(78_000))+ } else {+ "Ask me before publishing.".to_owned()+ };+ mount_sse_sequence(&server, vec![sse(vec![ev_completed("local-instruction")])]).await;+ worker+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: local_instruction.clone(),+ text_elements: Vec::new(),+ }]))+ .await?;+ wait_for_event(&worker, |event| matches!(event, EventMsg::TurnComplete(_))).await;+ if compacted {+ // Local compaction keeps the inherited source message in replacement history.+ mount_sse_sequence(+ &server,+ vec![sse(vec![+ ev_assistant_message("worker-summary", "Inspected the project."),+ ev_completed("worker-compacted"),+ ])],+ )+ .await;+ compact_and_assert_answers(&test, &worker, &[]).await?;+ }+ let worker_context = worker.conversation_history_snapshot().await;+ let inherited_text = worker_context+ .items()+ .find_map(|item| match item {+ ResponseItem::Message { role, content, .. } if role == "user" => {+ let [ContentItem::InputText { text }] = content.as_slice() else {+ return None;+ };+ text.starts_with("You may publish the release.")+ .then(|| text.clone())+ }+ _ => None,+ })+ .context("inherited source in worker history")?;+ if compacted {+ assert_ne!(inherited_text, instruction);+ assert!(inherited_text.contains("tokens truncated"));+ assert!(inherited_text.len() < 900 * 4);+ }+ // The adopted root later compacts through the mechanical path, which can drop originals.+ test.config+ .features+ .enable(Feature::TokenBudget)+ .expect("use mechanical root compaction");+ let fork = if history_mode == ThreadHistoryMode::Paginated {+ let prepared = test+ .thread_store+ .prepare_fork(PrepareForkParams {+ thread_id: worker.session_configured().thread_id,+ boundary: ForkBoundary::Latest,+ })+ .await?;+ test.thread_manager+ .fork_prepared_thread(+ test.config.clone(),+ prepared,+ /*thread_source*/ None,+ /*parent_trace*/ None,+ ClientMcpExtensions::default(),+ /*reserved_thread_id*/ None,+ )+ .await?+ } else {+ test.thread_manager+ .fork_thread_from_history(+ ForkSnapshot::Interrupted,+ test.config.clone(),+ InitialHistory::Resumed(ResumedHistory {+ conversation_id: worker.session_configured().thread_id,+ history: Arc::new(load_context(&test, &worker).await?),+ rollout_path: None,+ }),+ /*thread_source*/ None,+ /*parent_trace*/ None,+ ClientMcpExtensions::default(),+ /*reserved_thread_id*/ None,+ )+ .await?+ };+ assert!(fork.thread.guardian_root_snapshot().await.is_none());+ let history = fork.thread.conversation_history_snapshot().await;+ let retained = history.retained_context().context("root context")?;+ let answers = codex_guardian_context::render_verified_answers(retained);+ assert_eq!(+ (answers.fragments, answers.complete),+ (+ vec![codex_guardian_context::GuardianRootMessage::IncompleteVerifiedAnswers.render()],+ false+ ),+ );+ assert_eq!(+ retained+ .ordered_entries()+ .map(|(_, entry)| match entry {+ codex_history::RetainedContextEntry::UserMessage(message) =>+ (message.text.clone(), message.complete),+ codex_history::RetainedContextEntry::VerifiedAnswer(_) =>+ panic!("no answers before root adoption"),+ })+ .collect::<Vec<_>>(),+ vec![+ (inherited_text, !compacted),+ (+ codex_guardian_context::truncate_text(&local_instruction, /*max_tokens*/ 900),+ !compacted,+ ),+ ],+ );+ let after = record_answer(+ &fork.thread,+ &server,+ "root-action",+ "Do not publish.",+ /*acceptance_order*/ 2,+ )+ .await?;+ let expected = fork+ .thread+ .conversation_history_snapshot()+ .await+ .retained_context()+ .context("root after local answer")?+ .clone();+ assert!(!expected.verified_answers_complete());+ let root = fork.thread;+ compact_and_assert_answers(&test, &root, &[after]).await?;+ let root = resume(&test, &root).await?;+ assert_eq!(+ root.conversation_history_snapshot()+ .await+ .retained_context(),+ Some(&expected)+ );+ root.shutdown_and_wait().await?;+ worker.shutdown_and_wait().await?;+ Ok(())+}+#[test_case(false, true; "enabled without checkpoint")]#[test_case(true, true; "enabled after checkpoint")]#[test_case(false, false; "legacy without checkpoint")]diff --git a/codex-rs/core/tests/suite/guardian_subagent_authorization.rs b/codex-rs/core/tests/suite/guardian_subagent_authorization.rsindex df828c99dd..e11b940801 100644--- a/codex-rs/core/tests/suite/guardian_subagent_authorization.rs+++ b/codex-rs/core/tests/suite/guardian_subagent_authorization.rs@@ -657,11 +657,32 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(assert!(answer_position < queued_position);let mut partial =serde_json::to_value(history.retained_context().expect("retained root context"))?;+ let mut inherited_instruction = partial["user_messages"]+ .as_array()+ .expect("retained user-message records")+ .iter()+ .find(|entry| entry["text"] == INITIAL_PROMPT)+ .expect("initial instruction")+ .clone();+ inherited_instruction["inherited"] = json!(true);+ inherited_instruction["order"] = json!(+ original_history[queued_position]+ .metadata+ .as_ref()+ .expect("queued input metadata")+ .user_input_order+ .expect("queued acceptance order")+ );partial["user_messages"].as_array_mut().expect("retained user-message records").retain(|entry| entry["text"] == USER_APPROVAL);partial["user_messages_incomplete"] = json!(true);+ let mut inherited_prefix = partial.clone();+ inherited_prefix["user_messages"]+ .as_array_mut()+ .expect("retained user-message records")+ .push(inherited_instruction);let mut expected_authorization = expected_messages.into_iter().filter(|message| !matches!(message, GuardianRootMessage::Assistant(_)))@@ -684,12 +705,39 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization((partial, MissingCheckpointSource::RootInstruction, false),// Rebuild the local counter even when all retained metadata is absent.(Value::Null, MissingCheckpointSource::None, true),+ // Prefix and local orders can collide numerically. Recovery must keep+ // the inherited instruction first without losing the queued local grant.+ (inherited_prefix, MissingCheckpointSource::None, true),] {let mut expected = expected_authorization.clone();+ let inherited_message_id = retained["user_messages"]+ .as_array()+ .and_then(|entries| entries.iter().find(|entry| entry["inherited"] == true))+ .and_then(|entry| entry["message_id"].as_str());+ if inherited_message_id.is_some() {+ expected.insert(+ /*index*/ 2,+ GuardianRootMessage::IncompleteVerifiedAnswers,+ );+ }if retained.is_null() {expected.retain(|message| !matches!(message, GuardianRootMessage::UserInput(_)));}let mut replacement_history = original_history.clone();+ if let Some(id) = inherited_message_id {+ let metadata = replacement_history+ .iter_mut()+ .find(|envelope| {+ envelope+ .item+ .id()+ .is_some_and(|item_id| item_id.as_str() == id)+ })+ .and_then(|envelope| envelope.metadata.as_mut())+ .expect("inherited input metadata");+ metadata.inherited_user_message = true;+ metadata.user_input_order = Some(100);+ }match missing_source {MissingCheckpointSource::None => {}MissingCheckpointSource::VerifiedAnswer => {diff --git a/codex-rs/guardian-context/src/retained_instructions_tests.rs b/codex-rs/guardian-context/src/retained_instructions_tests.rsindex 9e21ece663..fa78ddd875 100644--- a/codex-rs/guardian-context/src/retained_instructions_tests.rs+++ b/codex-rs/guardian-context/src/retained_instructions_tests.rs@@ -1,5 +1,6 @@use super::*;use codex_history::RetainedContextEvent;+use codex_history::RetainedInputSource;use codex_history::RetainedUserMessage;use codex_history::VerifiedAnswer;use codex_history::VerifiedQuestionAnswer;@@ -28,7 +29,7 @@ fn instructions_preserve_source_order_and_whole_records() {text: "Do not publish after all.".to_owned(),complete: true,},- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);let rendered = render_retained_instructions(&context);assert_eq!(@@ -52,7 +53,7 @@ fn instructions_preserve_source_order_and_whole_records() {text: "Permission is conditional. ".repeat(200),complete: true,},- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);let rendered = render_retained_instructions(&context);assert_eq!(rendered.len(), 2);diff --git a/codex-rs/history/src/lib.rs b/codex-rs/history/src/lib.rsindex dd1b9ef05f..258c32291f 100644--- a/codex-rs/history/src/lib.rs+++ b/codex-rs/history/src/lib.rs@@ -173,6 +173,8 @@ pub use reconciled_retained_context::ReconciledRetainedContext;pub use retained_context::RetainedContext;pub use retained_context::RetainedContextEntry;pub use retained_context::RetainedContextEvent;+pub use retained_context::RetainedContextOrder;+pub use retained_context::RetainedInputSource;pub use retained_context::RetainedUserMessage;pub use retained_context::VerifiedAnswer;pub use retained_context::VerifiedQuestionAnswer;diff --git a/codex-rs/history/src/reconciled_retained_context.rs b/codex-rs/history/src/reconciled_retained_context.rsindex 3754044767..1343be6347 100644--- a/codex-rs/history/src/reconciled_retained_context.rs+++ b/codex-rs/history/src/reconciled_retained_context.rs@@ -6,12 +6,13 @@ use std::collections::HashSet;use crate::RetainedContext;use crate::RetainedContextEntry;+use crate::RetainedContextOrder;use crate::RetainedUserMessage;/// Retained evidence supplemented by surviving user messages without changing the checkpoint.pub struct ReconciledRetainedContext<'a> {retained_context: Option<&'a RetainedContext>,- recovered: Vec<(u64, RetainedUserMessage)>,+ recovered: Vec<(RetainedContextOrder, RetainedUserMessage)>,/// Instructions were already missing, or a recovered source could not be ordered.pub missing_user_messages: bool,}@@ -19,6 +20,7 @@ pub struct ReconciledRetainedContext<'a> {impl<'a> ReconciledRetainedContext<'a> {/// Reconciles eligible live user messages with retained sources in acceptance order./// The caller supplies original source identities and filters out non-user context.+ /// Inherited sources must supply no local order; retained identities match before ordering./// Live messages are consumed only when retained user instructions are incomplete.pub fn new(retained_context: Option<&'a RetainedContext>,@@ -57,7 +59,11 @@ impl<'a> ReconciledRetainedContext<'a> {}// Queued steering can enter raw history after a later-accepted answer.// Compare their persisted sequence numbers, including checkpoint-only answers.- let Some(order) = order.filter(|order| used_orders.insert(*order)) else {+ // Parent counters cannot establish an adopted prefix position.+ let Some(order) = order+ .map(RetainedContextOrder::Local)+ .filter(|order| used_orders.insert(*order))+ else {missing_user_messages = true;continue;};@@ -74,7 +80,7 @@ impl<'a> ReconciledRetainedContext<'a> {/// Returns retained and recovered evidence in persisted acceptance order.pub fn ordered_entries(&self,- ) -> impl DoubleEndedIterator<Item = (u64, RetainedContextEntry<'_>)> {+ ) -> impl DoubleEndedIterator<Item = (RetainedContextOrder, RetainedContextEntry<'_>)> {let mut entries = self.retained_context.into_iter()diff --git a/codex-rs/history/src/reconciled_retained_context_tests.rs b/codex-rs/history/src/reconciled_retained_context_tests.rsindex b851f23e19..baeb79d0dc 100644--- a/codex-rs/history/src/reconciled_retained_context_tests.rs+++ b/codex-rs/history/src/reconciled_retained_context_tests.rs@@ -1,5 +1,6 @@use super::*;use crate::RetainedContextEvent;+use crate::RetainedInputSource;use crate::VerifiedAnswer;use crate::VerifiedQuestionAnswer;use pretty_assertions::assert_eq;@@ -25,8 +26,8 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {..retained_excerpt.clone()};let mut retained = RetainedContext::default();- retained.record_user_message(initial.clone(), Some(0));- retained.record_user_message(retained_excerpt, Some(1));+ retained.record_user_message(initial.clone(), RetainedInputSource::Local(Some(0)));+ retained.record_user_message(retained_excerpt, RetainedInputSource::Local(Some(1)));retained.record(&RetainedContextEvent::VerifiedAnswer {answer: VerifiedAnswer {turn_id: "answer-turn".to_owned(),@@ -70,12 +71,15 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {),(vec![- (0, "Inspect the deployment."),- (1, ""),- (2, "Make the deployment public."),- (3, "Never publicly."),- (4, "Do not deploy after all."),- (5, "Inspect the deployment."),+ (RetainedContextOrder::Local(0), "Inspect the deployment."),+ (RetainedContextOrder::Local(1), ""),+ (+ RetainedContextOrder::Local(2),+ "Make the deployment public."+ ),+ (RetainedContextOrder::Local(3), "Never publicly."),+ (RetainedContextOrder::Local(4), "Do not deploy after all."),+ (RetainedContextOrder::Local(5), "Inspect the deployment."),],true,),@@ -86,7 +90,10 @@ fn recovery_preserves_source_identity_acceptance_order_and_checkpoint_gaps() {#[test]fn recovery_marks_missing_and_conflicting_orders_incomplete() {let mut retained = RetainedContext::default();- retained.record_user_message(instruction("Inspect the deployment."), Some(1));+ retained.record_user_message(+ instruction("Inspect the deployment."),+ RetainedInputSource::Local(Some(1)),+ );assert!(!retained.has_missing_user_messages());let checkpoint = retained.clone();@@ -111,7 +118,10 @@ fn recovery_marks_missing_and_conflicting_orders_incomplete() {reconciled.missing_user_messages,),(- vec![(1, "Inspect the deployment."), (2, "Do not deploy.")],+ vec![+ (RetainedContextOrder::Local(1), "Inspect the deployment."),+ (RetainedContextOrder::Local(2), "Do not deploy.")+ ],true,),"invalid order: {invalid_order:?}",diff --git a/codex-rs/history/src/retained_context.rs b/codex-rs/history/src/retained_context.rsindex 8c1f368819..ecc5c364c9 100644--- a/codex-rs/history/src/retained_context.rs+++ b/codex-rs/history/src/retained_context.rs@@ -1,5 +1,7 @@//! Bounded host-owned facts outside the model's compaction contract.//! Checkpoints and live recording use the same admission rules; rendering is a consumer concern.+//! Adopted parent instructions precede local facts without sharing the local acceptance counter.+//! Their parent verified answers are unavailable, so adopted authorization stays incomplete.use std::collections::VecDeque;@@ -7,6 +9,7 @@ use schemars::JsonSchema;use serde::Deserialize;use serde::Serialize;+use crate::CodexHarnessMetadata;use crate::ResponseItemEnvelope;const MAX_FAMILY_RECORDS: usize = 8;@@ -39,6 +42,33 @@ pub struct RetainedUserMessage {pub complete: bool,}+/// Local facts use their acceptance counter; copied parent instructions use prefix order.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum RetainedInputSource {+ Local(Option<u64>),+ Inherited,+}++impl RetainedInputSource {+ /// Parent counters never establish order within the owning thread.+ pub fn acceptance_order(self) -> Option<u64> {+ match self {+ Self::Local(order) => order,+ Self::Inherited => None,+ }+ }+}++impl From<Option<&CodexHarnessMetadata>> for RetainedInputSource {+ fn from(metadata: Option<&CodexHarnessMetadata>) -> Self {+ if metadata.is_some_and(|metadata| metadata.inherited_user_message) {+ Self::Inherited+ } else {+ Self::Local(metadata.and_then(|metadata| metadata.user_input_order))+ }+ }+}+impl std::fmt::Debug for RetainedUserMessage {fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {formatter@@ -50,12 +80,32 @@ impl std::fmt::Debug for RetainedUserMessage {#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]struct Ordered<T> {+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]+ inherited: bool,#[serde(default)]order: u64,#[serde(flatten)]value: T,}+impl<T> Ordered<T> {+ fn key(&self) -> RetainedContextOrder {+ if self.inherited {+ RetainedContextOrder::Inherited(self.order)+ } else {+ RetainedContextOrder::Local(self.order)+ }+ }+}++/// Inherited prefix order precedes the owning thread's local acceptance order.+/// The counters have separate scopes and must not be compared without their origin.+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]+pub enum RetainedContextOrder {+ Inherited(u64),+ Local(u64),+}+/// Borrowed host evidence across retained families.pub enum RetainedContextEntry<'a> {UserMessage(&'a RetainedUserMessage),@@ -108,7 +158,7 @@ fn legacy_user_messages_incomplete() -> bool {fn bound_family<T: Serialize>(items: &mut VecDeque<Ordered<T>>, incomplete: &mut bool) {// Queued instructions can be recorded after later-accepted answers. Evict by// acceptance order, not by the order in which persistence happened to finish.- items.make_contiguous().sort_by_key(|entry| entry.order);+ items.make_contiguous().sort_by_key(Ordered::key);while items.len() > MAX_FAMILY_RECORDS|| serde_json::to_vec(items).map_or(true, |bytes| bytes.len() > MAX_FAMILY_BYTES){@@ -196,24 +246,29 @@ impl RetainedContext {self.user_messages_incomplete = true;}- /// Returns retained evidence with its persisted order, shared across both families.- /// Explicit acceptance order survives delayed recording; legacy records use recording order.+ /// Whether a root checkpoint already contains its adopted instruction prefix.+ pub fn has_inherited_user_messages(&self) -> bool {+ self.user_messages.iter().any(|entry| entry.inherited)+ }++ /// Returns retained evidence with its origin and persisted order across both families.+ /// Explicit acceptance order survives delayed recording; inherited prefix order stays separate.pub fn ordered_entries(&self,- ) -> impl DoubleEndedIterator<Item = (u64, RetainedContextEntry<'_>)> {+ ) -> impl DoubleEndedIterator<Item = (RetainedContextOrder, RetainedContextEntry<'_>)> {let mut entries = self.verified_answers.iter().map(|entry| {(- entry.order,+ entry.key(),RetainedContextEntry::VerifiedAnswer(&entry.value),)}).chain(self.user_messages.iter()- .map(|entry| (entry.order, RetainedContextEntry::UserMessage(&entry.value))),+ .map(|entry| (entry.key(), RetainedContextEntry::UserMessage(&entry.value))),).collect::<Vec<_>>();entries.sort_by_key(|(order, _)| *order);@@ -222,22 +277,41 @@ impl RetainedContext {/// Records a delivered user item with its acceptance order. Legacy items without/// this metadata use recording order; checkpoint/suffix replay uses the same path.+ /// Inherited instructions use prefix order because their original counters belong to parents.pub fn record_user_message(&mut self,mut message: RetainedUserMessage,- acceptance_order: Option<u64>,+ source: RetainedInputSource,) {message.bound();+ let inherited = source == RetainedInputSource::Inherited;+ // Worker forks omit parent answer records. Adopting their instructions+ // cannot establish whether an omitted answer restricted an inherited grant.+ self.verified_answers_incomplete |= inherited;if let Some(index) = self.user_messages.iter().position(|entry| {message.message_id.is_some() && entry.value.message_id == message.message_id}) {- if self.user_messages[index].value == message {+ if self.user_messages[index].value == message+ && self.user_messages[index].inherited == inherited+ {return;}self.user_messages.remove(index);}- let order = self.record_order(acceptance_order);+ // Parent and worker counters have different scopes. Adopt the copied prefix+ // in history order without advancing the worker's local acceptance counter.+ let order = if inherited {+ self.user_messages+ .iter()+ .filter(|entry| entry.inherited)+ .map(|entry| entry.order.saturating_add(1))+ .max()+ .unwrap_or_default()+ } else {+ self.record_order(source.acceptance_order())+ };self.user_messages.push_back(Ordered {+ inherited,order,value: message,});@@ -283,6 +357,7 @@ impl RetainedContext {}let order = self.record_order(acceptance_order);self.verified_answers.push_back(Ordered {+ inherited: false,order,value: answer,});@@ -315,7 +390,11 @@ impl RetainedContext {}for entry in &mut self.user_messages {entry.value.bound();- self.next_order = self.next_order.max(entry.order.saturating_add(1));+ // Also repair checkpoints written before adoption recorded the answer gap.+ self.verified_answers_incomplete |= entry.inherited;+ if !entry.inherited {+ self.next_order = self.next_order.max(entry.order.saturating_add(1));+ }}for order in surviving_items.iter()@@ -345,18 +424,19 @@ impl RetainedContext {&mut self,turn_ids: &[&str],first_removed_message_id: Option<&str>,- acceptance_order: Option<u64>,+ source: RetainedInputSource,) {- if let Some(order) = acceptance_order.or_else(|| {+ let boundary = source.acceptance_order().map(RetainedContextOrder::Local);+ if let Some(boundary) = boundary.or_else(|| {first_removed_message_id.and_then(|id| {self.user_messages.iter().find(|message| message.value.message_id.as_deref() == Some(id))- .map(|message| message.order)+ .map(Ordered::key)})}) {- self.verified_answers.retain(|entry| entry.order < order);- self.user_messages.retain(|entry| entry.order < order);+ self.verified_answers.retain(|entry| entry.key() < boundary);+ self.user_messages.retain(|entry| entry.key() < boundary);return;}self.user_messages_incomplete |= first_removed_message_id.is_some()@@ -364,10 +444,14 @@ impl RetainedContext {.user_messages.iter().any(|message| turn_ids.contains(&message.value.turn_id.as_str()));- self.verified_answers- .retain(|answer| !turn_ids.contains(&answer.value.turn_id.as_str()));- self.user_messages- .retain(|message| !turn_ids.contains(&message.value.turn_id.as_str()));+ self.verified_answers.retain(|answer| {+ source != RetainedInputSource::Inherited+ && !turn_ids.contains(&answer.value.turn_id.as_str())+ });+ self.user_messages.retain(|message| {+ (source != RetainedInputSource::Inherited || message.inherited)+ && !turn_ids.contains(&message.value.turn_id.as_str())+ });}}diff --git a/codex-rs/history/src/retained_context_tests.rs b/codex-rs/history/src/retained_context_tests.rsindex d3c01cbf6d..9b5bf65f99 100644--- a/codex-rs/history/src/retained_context_tests.rs+++ b/codex-rs/history/src/retained_context_tests.rs@@ -31,7 +31,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()text: String::new(),complete: false,},- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);let mut expected = context.clone();expected.user_messages[0].value.text = "Do not publish after all.".to_owned();@@ -63,7 +63,7 @@ fn retained_evidence_preserves_order_through_recovery_checkpoint_and_rollback()restored.rollback(&["revocation-turn"],Some("revocation"),- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);assert_eq!(restored,@@ -99,7 +99,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {context.rollback(&["turn-2"],/*first_removed_message_id*/ None,- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);assert_eq!(context.verified_answers().count(), 0);assert!(!context.verified_answers_complete());@@ -135,7 +135,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {text: "Keep the repository private.".to_owned(),complete: true,},- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);}assert!(!restored.user_messages_complete());@@ -154,7 +154,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {text: "An older queued instruction.".to_owned(),complete: true,},- Some(0),+ RetainedInputSource::Local(Some(0)),);assert_eq!(restored, recent,@@ -167,7 +167,7 @@ fn retained_families_enforce_storage_limits_without_changing_snapshots() {text: "restriction ".repeat(MAX_RECORD_BYTES),complete: true,},- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);let Some((_, RetainedContextEntry::UserMessage(message))) =restored.ordered_entries().next_back()@@ -188,7 +188,7 @@ fn recovered_excerpts_obey_record_and_family_limits() {text: String::new(),complete: false,},- /*acceptance_order*/ None,+ RetainedInputSource::Local(None),);}let unchanged = context.clone();@@ -281,10 +281,13 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {text: "Keep the repository private.".to_owned(),complete: true,};- context.record_user_message(instruction.clone(), Some(steer_order));+ context.record_user_message(+ instruction.clone(),+ RetainedInputSource::Local(Some(steer_order)),+ );let mut resumed = RetainedContext::default();resumed.restore(Some(&checkpoint), &[]);- resumed.record_user_message(instruction, Some(steer_order));+ resumed.record_user_message(instruction, RetainedInputSource::Local(Some(steer_order)));assert_eq!(resumed, context);assert_eq!(resumed@@ -297,15 +300,29 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {}).collect::<Vec<_>>(),vec![- (steer_order, "Keep the repository private."),- (answer_order, "Yes, but never publicly."),+ (+ RetainedContextOrder::Local(steer_order),+ "Keep the repository private."+ ),+ (+ RetainedContextOrder::Local(answer_order),+ "Yes, but never publicly."+ ),],);// This checkpoint predates model delivery of the queued instruction. Rollback// still removes its later-accepted answer using the persisted boundary order.let mut before_delivery = checkpoint;- before_delivery.rollback(&["turn-1"], Some("steer"), Some(steer_order));- resumed.rollback(&["turn-1"], Some("steer"), Some(steer_order));+ before_delivery.rollback(+ &["turn-1"],+ Some("steer"),+ RetainedInputSource::Local(Some(steer_order)),+ );+ resumed.rollback(+ &["turn-1"],+ Some("steer"),+ RetainedInputSource::Local(Some(steer_order)),+ );assert_eq!(before_delivery, resumed);assert_eq!(resumed,@@ -315,3 +332,57 @@ fn accepted_order_survives_delayed_recording_and_checkpoint_replay() {});}++#[test]+fn adopted_instructions_preserve_local_order_and_rollback_scope() {+ let mut context = RetainedContext::default();+ context.record(&publish_answer());+ for index in 0..2 {+ let message = RetainedUserMessage {+ turn_id: "parent-turn".to_owned(),+ message_id: Some(format!("parent-{index}")),+ text: format!("Parent instruction {index}"),+ complete: true,+ };+ context.record_user_message(message.clone(), RetainedInputSource::Inherited);+ context.record_user_message(message, RetainedInputSource::Inherited);+ }+ assert_eq!(context.reserve_order(), 1);+ assert!(!context.verified_answers_complete());+ assert_eq!(+ context+ .ordered_entries()+ .map(|(order, _)| order)+ .collect::<Vec<_>>(),+ vec![+ RetainedContextOrder::Inherited(0),+ RetainedContextOrder::Inherited(1),+ RetainedContextOrder::Local(0)+ ],+ );+ let checkpoint = serde_json::from_slice(&serde_json::to_vec(&context).unwrap()).unwrap();+ let mut restored = RetainedContext::default();+ restored.restore(Some(&checkpoint), &[]);+ assert_eq!(restored, context);+ // Older roots adopted complete instructions without recording the missing parent answers.+ let mut legacy_checkpoint = serde_json::to_value(&checkpoint).unwrap();+ legacy_checkpoint["incomplete"] = serde_json::json!(false);+ let legacy_checkpoint = serde_json::from_value(legacy_checkpoint).unwrap();+ restored.restore(Some(&legacy_checkpoint), &[]);+ assert_eq!(restored, context);+ restored.rollback(+ &["turn-1"],+ /*first_removed_message_id*/ None,+ RetainedInputSource::Local(Some(0)),+ );+ let mut expected = context;+ expected.verified_answers.clear();+ assert_eq!(restored, expected);+ restored.rollback(+ &["parent-turn"],+ Some("parent-1"),+ RetainedInputSource::Inherited,+ );+ expected.user_messages.pop_back();+ assert_eq!(restored, expected);+}diff --git a/codex-rs/rollout/src/lib.rs b/codex-rs/rollout/src/lib.rsindex 390b1d08b6..462d0f0260 100644--- a/codex-rs/rollout/src/lib.rs+++ b/codex-rs/rollout/src/lib.rs@@ -31,6 +31,7 @@ pub use codex_history::ResponseItemEnvelope;pub use codex_history::ResumedHistory;pub use codex_history::RetainedContextEntry;pub use codex_history::RetainedContextEvent;+pub use codex_history::RetainedInputSource;pub use codex_history::RolloutItem;pub use codex_history::RolloutLine;pub(crate) use codex_protocol::protocol;diff --git a/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs b/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rsindex 6da7264cd3..588ac37787 100644--- a/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs+++ b/codex-rs/thread-store/src/local/rollout_migration/rollback_plan.rs@@ -17,6 +17,7 @@ use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::UserMessageEvent;use codex_rollout::CompactedItem;use codex_rollout::RetainedContextEntry;+use codex_rollout::RetainedInputSource;use codex_rollout::RolloutItem;use codex_rollout::RolloutLine;@@ -42,7 +43,7 @@ struct PendingUserResponse {struct InstructionBoundary {record_index: usize,message_id: Option<ResponseItemId>,- acceptance_order: Option<u64>,+ input_source: RetainedInputSource,alive: bool,}@@ -161,10 +162,7 @@ impl RollbackPlanner {} else if rollback::counts_as_boundary(&response.item) {let boundary = self.start_boundary(index);self.boundaries[boundary].message_id = response.id().cloned();- self.boundaries[boundary].acceptance_order = response- .metadata- .as_ref()- .and_then(|metadata| metadata.user_input_order);+ self.boundaries[boundary].input_source = response.metadata.as_ref().into();if let ResponseItem::Message { role, content, .. } = &response.item&& role == "user"{@@ -323,7 +321,7 @@ impl RollbackPlanner {self.boundaries.push(InstructionBoundary {record_index: index,message_id: None,- acceptance_order: None,+ input_source: RetainedInputSource::Local(None),alive: true,});let had_prior_boundary = !self.boundary_stack.is_empty();@@ -380,7 +378,8 @@ impl RollbackPlanner {}if let Some(boundary) = first_removed_boundary {let source = &self.boundaries[boundary];- if let Some(order) = source.acceptance_order {+ let acceptance_order = source.input_source.acceptance_order();+ if let Some(order) = acceptance_order {// An answer may have been persisted before the queued instruction// accepted ahead of it. Both are removed at that acceptance boundary.for fact in &self.retained_fact_sources {@@ -411,10 +410,10 @@ impl RollbackPlanner {// including in checkpoints. Legacy evidence uses the recorded boundary.// Later checkpoints have not been observed yet and already reflect this rollback.for frame in self.compactions.iter_mut().rev().take_while(|frame| {- source.acceptance_order.is_some() || frame.record_index >= source.record_index+ acceptance_order.is_some() || frame.record_index >= source.record_index}) {if let Some(context) = &mut frame.item.retained_context {- if source.acceptance_order.is_some()+ if acceptance_order.is_some()|| context.ordered_entries().any(|(_, entry)| matches!(entry, RetainedContextEntry::UserMessage(_)))@@ -422,7 +421,7 @@ impl RollbackPlanner {context.rollback(&removed_turns,source.message_id.as_ref().map(ResponseItemId::as_str),- source.acceptance_order,+ source.input_source,);} else {// Checkpoints written without instruction retention keep the legacy