diff --git a/codex-rs/core/src/agent/control/sender_context.rs b/codex-rs/core/src/agent/control/sender_context.rs index b84082fff7..af2c650155 100644 --- a/codex-rs/core/src/agent/control/sender_context.rs +++ b/codex-rs/core/src/agent/control/sender_context.rs @@ -7,10 +7,13 @@ use crate::context::GuardianSenderMessages; use crate::context_manager::ContextManager; use crate::session::session::Session; use codex_history::RolloutItem; +use codex_protocol::SessionId; use codex_protocol::ThreadId; use codex_protocol::models::ResponseItem; +use codex_protocol::protocol::ThreadHistoryMode; use codex_thread_store::LoadThreadHistoryParams; use codex_utils_output_truncation::TruncationPolicy; +use std::sync::Arc; use std::time::Duration; use super::LocalAgentRuntime; @@ -90,29 +93,52 @@ impl LocalAgentRuntime { }), ) .await; - match stored { - Ok(Ok(stored)) if stored.thread_id == source_thread_id => { - let meta = stored.items.iter().find_map(|item| match item { - RolloutItem::SessionMeta(meta) => Some(&meta.meta), - _ => None, - }); - meta.filter(|meta| { - meta.id == source_thread_id && !meta.source.is_internal() - }) - .map(|meta| { - fragment.from_storage = true; - ContextManager::reconstruct_rollout( - &stored.items, - meta.history_mode, - ContextManager::new(Session::new_item_id_generator()), - // Tool bodies are not sender authorization evidence. - TruncationPolicy::Bytes(0), - ) - .retained_context - }) + let capture = || { + let stored = stored.ok()?.ok()?; + if stored.thread_id != source_thread_id { + return None; } - Ok(Ok(_)) | Ok(Err(_)) | Err(_) => None, - } + let RolloutItem::SessionMeta(meta) = stored.items.first()? else { + return None; + }; + if meta.meta.id != source_thread_id || meta.meta.source.is_internal() { + return None; + } + let history_mode = meta.meta.history_mode; + let referenced_agent_fork = meta.meta.history_base.is_some() + && meta.meta.session_id != SessionId::from(source_thread_id) + && meta.meta.subagent_history_start_ordinal.is_none(); + let version = if referenced_agent_fork { + if history_mode != ThreadHistoryMode::Paginated + || meta.meta.forked_from_id.is_none() + { + return None; + } + Some(meta.meta.multi_agent_version?) + } else { + None + }; + let mut history = Arc::new(stored.items); + if let Some(version) = version { + crate::agent::sanitize_referenced_agent_fork( + source_thread_id, + &mut history, + version, + ) + .ok()?; + } + let context = ContextManager::reconstruct_rollout( + &history, + history_mode, + ContextManager::new(Session::new_item_id_generator()), + // Tool bodies are not sender authorization evidence. + TruncationPolicy::Bytes(0), + ) + .retained_context; + fragment.from_storage = true; + Some(context) + }; + capture() } }; if let Some(context) = context { diff --git a/codex-rs/core/src/agent/history.rs b/codex-rs/core/src/agent/history.rs index da21538526..1a2b638180 100644 --- a/codex-rs/core/src/agent/history.rs +++ b/codex-rs/core/src/agent/history.rs @@ -29,6 +29,7 @@ use codex_history::InitialHistory; use codex_history::ResponseItemEnvelope; use codex_history::RolloutItem; use codex_prompts::ResolvedModelMessages; +use codex_protocol::SessionId; use codex_protocol::ThreadId; use codex_protocol::error::CodexErr; use codex_protocol::error::Result as CodexResult; @@ -41,6 +42,153 @@ use codex_protocol::protocol::SessionSource; use codex_protocol::protocol::SubAgentSource; use codex_protocol::protocol::ThreadHistoryMode; use codex_thread_store::LoadThreadHistoryParams; +use std::sync::Arc; + +fn sanitize_forked_rollout_item( + item: &mut RolloutItem, + version: MultiAgentVersion, + preserve_context_baselines: bool, + preserve_fork_prefix: bool, + history_mode: ThreadHistoryMode, + mut retain_response: impl FnMut(&mut ResponseItemEnvelope) -> bool, +) -> bool { + if !((preserve_fork_prefix && matches!(item, RolloutItem::ResponseItem(_))) + || keep_forked_rollout_item(item, preserve_context_baselines)) + || history_mode == ThreadHistoryMode::Paginated + && matches!( + item, + RolloutItem::EventMsg( + EventMsg::ItemCompleted(_) + | EventMsg::TokenCount(_) + | EventMsg::ThreadGoalUpdated(_) + | EventMsg::ThreadSettingsApplied(_) + ) + ) + { + return false; + } + let mut retain_envelope = |envelope: &mut ResponseItemEnvelope| { + let explicitly_retained = envelope.is_always_retained(); + if preserve_fork_prefix + || explicitly_retained + || (version == MultiAgentVersion::V2 + && matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user" || role == "assistant")) + { + envelope + .metadata + .get_or_insert_default() + .inherited_user_message = true; + } + if let Some(metadata) = &mut envelope.metadata + && (metadata.sender_user_messages.take().is_some() + || !matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user")) + { + metadata.user_input_order = None; + } + preserve_fork_prefix || explicitly_retained || retain_response(envelope) + }; + match item { + RolloutItem::ResponseItem(envelope) => retain_envelope(envelope), + RolloutItem::Compacted(compacted) => { + compacted.latest_token_usage_record = None; + if let Some(metadata) = &mut compacted.resume_metadata { + metadata.multi_agent_version = Some(version); + metadata.turn_attribution = None; + if !preserve_context_baselines { + metadata.previous_turn_settings = None; + } + } + compacted.guardian_history = None; + compacted.retained_context = + (version == MultiAgentVersion::V2).then(codex_history::RetainedContext::default); + if let Some(history) = &mut compacted.replacement_history { + history.retain_mut(&mut retain_envelope); + } + true + } + RolloutItem::WorldState(world_state) + if version == MultiAgentVersion::V2 || preserve_fork_prefix => + { + world_state.state.remove("multi_agent_usage_hint"); + true + } + _ => true, + } +} + +/// Project an ancestor prefix as agent context without changing referenced source history. +pub(crate) fn sanitize_agent_fork_prefix( + items: &mut Vec, + prefix_len: usize, + version: MultiAgentVersion, +) -> usize { + let prefix_len = prefix_len.min(items.len()); + let removed = items + .extract_if(..prefix_len, |item| { + !sanitize_forked_rollout_item( + item, + version, + /*preserve_context_baselines*/ true, + /*preserve_fork_prefix*/ true, + ThreadHistoryMode::Paginated, + |_| true, + ) + }) + .count(); + prefix_len - removed +} + +/// Project immutable ancestor ranges when reading a referenced agent fork. +pub(crate) fn sanitize_referenced_agent_fork( + thread_id: ThreadId, + history: &mut Arc>, + version: MultiAgentVersion, +) -> CodexResult<()> { + let Some(RolloutItem::SessionMeta(meta)) = history.first() else { + return Ok(()); + }; + let Some(history_base) = meta.meta.history_base else { + return Ok(()); + }; + if meta.meta.id != thread_id + || meta.meta.forked_from_id.is_none() + || meta.meta.subagent_history_start_ordinal.is_some() + || meta.meta.session_id == SessionId::from(thread_id) + { + return Ok(()); + } + let boundary = history + .iter() + .position(|item| match item { + RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => { + event.thread_id == Some(thread_id) + } + // A bounded context scan can begin at a child-owned compaction, omitting + // the original startup event. Its catalog snapshot identifies its owner. + RolloutItem::Compacted(checkpoint) => checkpoint + .resume_metadata + .as_ref() + .and_then(|metadata| metadata.dynamic_tools.as_ref()) + .is_some_and(|snapshot| snapshot.thread_id == thread_id), + _ => false, + }) + .or_else(|| { + // Revert can truncate before the child's startup event. If the + // physical base ends inside the logical parent prefix, all surviving + // context is inherited. + meta.meta + .forked_from_ordinal_exclusive + .filter(|cutoff| history_base.end_ordinal_exclusive <= *cutoff) + .map(|_| history.len()) + }) + .ok_or_else(|| { + CodexErr::InvalidRequest( + "referenced agent fork history is missing its child boundary".to_string(), + ) + })?; + sanitize_agent_fork_prefix(Arc::make_mut(history), boundary, version); + Ok(()) +} impl LocalAgentRuntime { pub(crate) async fn retained_items_for_fresh_child( @@ -302,28 +450,6 @@ pub(super) async fn prepare_forked_history( forked_rollout_items = items; } let retain_forked_item = |envelope: &mut ResponseItemEnvelope, replaced: &mut bool| { - let explicitly_retained = envelope.is_always_retained(); - if explicitly_retained - || (multi_agent_version == MultiAgentVersion::V2 - && (preserve_fork_prefix - || matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user" || role == "assistant"))) - { - // Resume must not recapture copied parent messages as local authorization. - envelope - .metadata - .get_or_insert_default() - .inherited_user_message = true; - } - if let Some(metadata) = &mut envelope.metadata - && (metadata.sender_user_messages.take().is_some() - || !matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user")) - { - // Assistant and tool positions belong to the parent counter, not the child. - metadata.user_input_order = None; - } - if preserve_fork_prefix || explicitly_retained { - return true; - } let response_item = &mut envelope.item; // Tool declarations and their comparison baseline must survive or be rebuilt together. // Apply this to both standalone items and compaction replacement histories. @@ -389,74 +515,18 @@ pub(super) async fn prepare_forked_history( true }; forked_rollout_items.retain_mut(|item| { - let keep = (preserve_fork_prefix && matches!(item, RolloutItem::ResponseItem(_))) - || keep_forked_rollout_item(item, preserve_context_baselines); - if !keep - || destination_history_mode == Some(ThreadHistoryMode::Paginated) - && matches!( - &*item, - RolloutItem::EventMsg( - EventMsg::ItemCompleted(_) - | EventMsg::TokenCount(_) - | EventMsg::ThreadGoalUpdated(_) - | EventMsg::ThreadSettingsApplied(_), - ) - ) - { - return false; - } - - match item { - RolloutItem::ResponseItem(response_item) => { - retain_forked_item(response_item, &mut replaced_parent_developer_instructions) - } - RolloutItem::Compacted(compacted) => { - // This compaction becomes part of the subagent's initial history. Rewrite its - // metadata to describe the child rather than the parent. - compacted.latest_token_usage_record = None; - if let Some(resume_metadata) = &mut compacted.resume_metadata { - resume_metadata.multi_agent_version = Some(multi_agent_version); - resume_metadata.turn_attribution = None; - if !preserve_context_baselines { - resume_metadata.previous_turn_settings = None; - } - } - // Parent-local review evidence must not become the child's authorization. - // Root user authorization is collected separately by the host. - compacted.guardian_history = None; - // Only V2 fetches root authorization live. Its local scope starts known-empty; - // V1 must remain incomplete when inherited authorization has been stripped. - compacted.retained_context = (multi_agent_version == MultiAgentVersion::V2) - .then(codex_history::RetainedContext::default); - if let Some(replacement_history) = compacted.replacement_history.as_mut() { - // Matches before this checkpoint cannot survive its replacement history. - replaced_parent_developer_instructions = false; - replacement_history.retain_mut(|response_item| { - retain_forked_item( - response_item, - &mut replaced_parent_developer_instructions, - ) - }); - } - true - } - RolloutItem::WorldState(world_state) => { - if multi_agent_version == MultiAgentVersion::V2 { - world_state.state.remove("multi_agent_usage_hint"); - } - true - } - RolloutItem::RealtimeItem(_) => false, - RolloutItem::DynamicToolsUpdated { .. } - | RolloutItem::EventMsg(_) - | RolloutItem::SessionMeta(_) - | RolloutItem::TurnContext(_) - | RolloutItem::InterAgentCommunication(_) - | RolloutItem::InterAgentCommunicationMetadata { .. } => true, - RolloutItem::RetainedContext(_) - | RolloutItem::TokenUsageRecord(_) - | RolloutItem::SecurityRiskScore(_) => false, + if matches!(item, RolloutItem::Compacted(checkpoint) if checkpoint.replacement_history.is_some()) { + // Matches before this checkpoint cannot survive its replacement history. + replaced_parent_developer_instructions = false; } + sanitize_forked_rollout_item( + item, + multi_agent_version, + preserve_context_baselines, + preserve_fork_prefix, + parent_history_mode, + |response| retain_forked_item(response, &mut replaced_parent_developer_instructions), + ) }); if preserve_fork_prefix { forked_rollout_items.push(RolloutItem::ResponseItem( diff --git a/codex-rs/core/src/agent/host/types.rs b/codex-rs/core/src/agent/host/types.rs index e768ced684..2e245a5484 100644 --- a/codex-rs/core/src/agent/host/types.rs +++ b/codex-rs/core/src/agent/host/types.rs @@ -33,7 +33,7 @@ use std::sync::Arc; #[derive(Clone, Copy, Debug)] pub struct RestrictRootCapabilities; -/// The root's session ID, supplied by a trusted host when starting a new or forked child. +/// The root's session ID, supplied by a trusted host for a fresh child or a prepared fork. /// /// Insert this into the thread's startup [`codex_extension_api::ExtensionDataInit`]. /// The child keeps its own distinct thread ID. Resumed threads take their session diff --git a/codex-rs/core/src/agent/mod.rs b/codex-rs/core/src/agent/mod.rs index 0b7518b820..1842f5fb9d 100644 --- a/codex-rs/core/src/agent/mod.rs +++ b/codex-rs/core/src/agent/mod.rs @@ -12,6 +12,8 @@ pub(crate) mod types; pub(crate) use codex_protocol::protocol::AgentStatus; pub(crate) use control::LocalAgentControl; +pub(crate) use history::sanitize_agent_fork_prefix; +pub(crate) use history::sanitize_referenced_agent_fork; pub(crate) use registry::exceeds_thread_spawn_depth_limit; pub(crate) use registry::next_thread_spawn_depth; pub(crate) use status::agent_status_from_event; diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs index 65a46418e4..e14d15b4ae 100644 --- a/codex-rs/core/src/session/session.rs +++ b/codex-rs/core/src/session/session.rs @@ -1293,11 +1293,18 @@ impl Session { })?; // Keep the large initialization future out of callers' stack frames. let session_result: anyhow::Result> = Box::pin(async { - if let InitialHistory::Resumed(resumed) = &mut initial_history - && let Some(history) = resume_context - { - resumed.history = history; - resumed.history_revision = None; + if let InitialHistory::Resumed(resumed) = &mut initial_history { + if let Some(history) = resume_context { + resumed.history = history; + resumed.history_revision = None; + } + let version = initial_multi_agent_version + .unwrap_or_else(|| config.multi_agent_version_from_features()); + crate::agent::sanitize_referenced_agent_fork( + resumed.conversation_id, + &mut resumed.history, + version, + )?; } let super::model_ids::InitialModelIds { item_id_generator, diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rs index cc00dab5b0..3379c02499 100644 --- a/codex-rs/core/src/thread_manager.rs +++ b/codex-rs/core/src/thread_manager.rs @@ -1874,6 +1874,7 @@ impl ThreadManager { } /// Fork an existing thread from already-loaded store history. + /// For an inherited session ID, use [`Self::fork_prepared_thread`] instead. pub async fn fork_thread_from_history( &self, snapshot: S, @@ -1932,7 +1933,7 @@ impl ThreadManager { let ForkHistory { snapshot, initial_history: history, - persistence: fork_persistence, + persistence: mut fork_persistence, } = fork_history; // `forked_from_id()` describes this history's existing lineage. When // forking a resumed thread, the child copies the resumed thread itself. @@ -1970,6 +1971,29 @@ impl ThreadManager { multi_agent_version, ); options.initial_history = fork_history_from_snapshot(snapshot, history, interrupted_marker); + if options + .thread_extension_init + .get::() + .is_some() + && let ForkPersistence::Referenced { + inherited_item_count, + .. + } = &mut fork_persistence + && let InitialHistory::Forked(items) = &mut options.initial_history + { + if options.disabled_plugin_ids.is_none() + && let Some(thread_id) = source_thread_id + { + options.disabled_plugin_ids = + codex_history::latest_disabled_plugin_ids(items, thread_id) + .map(<[String]>::to_vec); + } + *inherited_item_count = crate::agent::sanitize_agent_fork_prefix( + items, + *inherited_item_count, + multi_agent_version, + ); + } let agent_control = self.agent_control_for_config(&options.config); let mut request = ThreadSpawnRequest::new(options, Arc::clone(&self.state.auth_manager), agent_control); @@ -2623,13 +2647,18 @@ impl ThreadManagerState { let inherited_environments = captured_environments.or(inherited_environments); let session_source = session_source.unwrap_or_else(|| self.session_source.clone()); if thread_extension_init.get::().is_some() - && (!matches!( - &initial_history, - InitialHistory::New | InitialHistory::Forked(_) - ) || session_source.is_non_root_agent()) + && (session_source.is_non_root_agent() + || !matches!( + (&initial_history, &fork_persistence), + (InitialHistory::New, _) + | ( + InitialHistory::Forked(_), + ForkPersistence::Referenced { .. } + ) + )) { return Err(CodexErr::InvalidRequest( - "an inherited agent session ID requires a new or forked thread started directly by the host" + "an inherited agent session ID requires a new thread or a prepared fork started directly by the host" .to_string(), )); } diff --git a/codex-rs/core/tests/suite/agent_control_tests.rs b/codex-rs/core/tests/suite/agent_control_tests.rs index 36ae27736d..9561aa6197 100644 --- a/codex-rs/core/tests/suite/agent_control_tests.rs +++ b/codex-rs/core/tests/suite/agent_control_tests.rs @@ -21,6 +21,7 @@ use codex_core::GuardianRootSnapshot; use codex_core::InheritedSessionId; use codex_core::LiveAgent; use codex_core::PendingAgentMessage; +use codex_core::RestrictRootCapabilities; use codex_core::RolloutBudgetReminder; use codex_core::SendRequest; use codex_core::SpawnRequest; @@ -30,6 +31,7 @@ use codex_core::TurnInput; use codex_core::TurnInputRequest; use codex_core::TurnInputSubmission; use codex_core::TurnStartOptions; +use codex_core::compact::content_items_to_text; use codex_core::config::Config; use codex_extension_api::ExtensionFuture; use codex_extension_api::ExtensionRegistryBuilder; @@ -39,9 +41,17 @@ use codex_extension_api::ThreadStopInput; use codex_extension_api::TurnLifecycleContributor; use codex_extension_api::TurnStopInput; use codex_features::Feature; +use codex_history::CodexHarnessMetadata; use codex_history::InitialHistory; +use codex_history::ResponseItemEnvelope; use codex_history::ResumedHistory; +use codex_history::RetainedContextEntry; +use codex_history::RetainedContextEvent; +use codex_history::RetainedContextOrder; use codex_history::RolloutItem; +use codex_history::SenderUserMessages; +use codex_history::VerifiedAnswer; +use codex_history::VerifiedQuestionAnswer; use codex_message_board::PostMetadata; use codex_protocol::AgentPath; use codex_protocol::SessionId; @@ -49,6 +59,7 @@ use codex_protocol::ThreadId; use codex_protocol::error::CodexErr; use codex_protocol::error::CodexErrorDetails; use codex_protocol::error::Result as CodexResult; +use codex_protocol::models::ResponseItem; use codex_protocol::protocol::AgentStatus; use codex_protocol::protocol::InterAgentCommunication; use codex_protocol::protocol::MultiAgentVersion; @@ -56,6 +67,7 @@ use codex_protocol::protocol::Op; use codex_protocol::protocol::SessionSource; use codex_protocol::protocol::SubAgentSource; use codex_protocol::protocol::ThreadHistoryMode; +use codex_protocol::protocol::ThreadSettingsOverrides; use codex_protocol::protocol::ThreadSource; use codex_protocol::protocol::TokenUsage; use codex_protocol::user_input::UserInput; @@ -66,6 +78,7 @@ use codex_thread_store::PrepareForkParams; use core_test_support::ThreadIdle; use core_test_support::responses; use core_test_support::skip_if_no_network; +use core_test_support::submit_thread_settings; use core_test_support::test_codex::TestCodex; use core_test_support::test_codex::test_codex; use core_test_support::wait_for_event; @@ -555,6 +568,20 @@ async fn host_factory_follows_thread_lifecycle() -> anyhow::Result<()> { history: Arc::new(saved.items), rollout_path: test.codex.rollout_path(), }); + let mut copied_child_options = options(); + copied_child_options + .thread_extension_init + .insert(InheritedSessionId(test.session_configured.session_id)); + assert!(matches!( + manager + .fork_thread_from_history( + ForkSnapshot::Interrupted, + copied_child_options, + history.clone(), + ) + .await, + Err(error) if matches!(error.details(), CodexErrorDetails::InvalidRequest(_)) + )); let fork = manager .fork_thread_from_history(ForkSnapshot::Interrupted, options(), history.clone()) .await?; @@ -635,13 +662,58 @@ async fn hosted_child_persists_inherited_session_id( CodexErrorDetails::InvalidRequest(_) )); let mut child_options = options(); + let prepared_fork = matches!(child_history, HostedChildHistory::PreparedFork); + let selected_plugins = vec!["slack@openai".to_string()]; child_options .thread_extension_init .insert(InheritedSessionId(root_session_id)); + if prepared_fork { + child_options + .thread_extension_init + .insert(RestrictRootCapabilities); + } let child = match child_history { HostedChildHistory::Fresh => manager.start_thread(child_options).await?, HostedChildHistory::PreparedFork => { + responses::mount_sse_once(&server, responses::sse_completed("done")).await; + root.submit_text_turn("record the current plugin selection") + .await?; + submit_thread_settings( + &root.codex, + ThreadSettingsOverrides { + disabled_plugin_ids: Some(selected_plugins.clone()), + ..Default::default() + }, + ) + .await?; root.codex.ensure_rollout_materialized().await; + root.codex + .append_rollout_items(&[ + RolloutItem::ResponseItem(ResponseItemEnvelope { + item: responses::user_message_item("ancestor instructions"), + metadata: Some(CodexHarnessMetadata { + user_input_order: Some(42), + sender_user_messages: Some(Box::new(SenderUserMessages { + receiver_turn_id: "ancestor-turn".into(), + receiver_message_id: "ancestor-message".into(), + text: "ancestor sender evidence".into(), + })), + ..Default::default() + }), + }), + RolloutItem::RetainedContext(RetainedContextEvent::VerifiedAnswer { + answer: VerifiedAnswer { + turn_id: "ancestor-turn".into(), + call_id: "ancestor-question".into(), + questions: vec![VerifiedQuestionAnswer { + question: "Publish?".into(), + answer: "Yes".into(), + }], + }, + acceptance_order: Some(43), + }), + ]) + .await?; root.codex.flush_rollout().await?; let prepared = root .thread_store @@ -663,6 +735,39 @@ async fn hosted_child_persists_inherited_session_id( ), (root_session_id, None) ); + let mut expected_retained = None; + if prepared_fork { + assert_eq!( + child + .thread + .thread_settings_snapshot() + .await + .disabled_plugin_ids, + selected_plugins + ); + let snapshot = child.thread.conversation_history_snapshot().await; + assert!(snapshot.items().any(|item| matches!( + item, ResponseItem::Message { role, content, .. } + if role == "user" && content_items_to_text(content).as_deref() == Some("ancestor instructions") + ))); + let retained = snapshot.retained_context().expect("child authorization"); + assert_eq!(retained.ordered_entries().count(), 0); + assert!(retained.sender_user_messages().is_none()); + child + .thread + .inject_response_items(vec![responses::user_message_item( + "child-local instructions", + )]) + .await?; + let snapshot = child.thread.conversation_history_snapshot().await; + let retained = snapshot.retained_context().expect("local authorization"); + assert!(matches!( + retained.ordered_entries().next(), + Some((RetainedContextOrder::Local(0), RetainedContextEntry::UserMessage(message))) + if message.text == "child-local instructions" + )); + expected_retained = Some(retained.clone()); + } child.thread.ensure_rollout_materialized().await; child.thread.flush_rollout().await?; let history = root @@ -700,12 +805,16 @@ async fn hosted_child_persists_inherited_session_id( error.details(), CodexErrorDetails::InvalidRequest(_) )); - let resumed = manager - .start_thread(StartThreadOptions { - initial_history: resumed_history, - ..options() - }) - .await?; + let mut resume_options = StartThreadOptions { + initial_history: resumed_history, + ..options() + }; + if prepared_fork { + resume_options + .thread_extension_init + .insert(RestrictRootCapabilities); + } + let resumed = manager.start_thread(resume_options).await?; assert!(!Arc::ptr_eq(&resumed.thread, &child.thread)); assert_eq!( ( @@ -715,6 +824,22 @@ async fn hosted_child_persists_inherited_session_id( ), (child.thread_id, root_session_id, None) ); + if let Some(expected_retained) = expected_retained { + assert_eq!( + resumed + .thread + .thread_settings_snapshot() + .await + .disabled_plugin_ids, + selected_plugins + ); + let snapshot = resumed.thread.conversation_history_snapshot().await; + assert!(snapshot.items().any(|item| matches!( + item, ResponseItem::Message { role, content, .. } + if role == "user" && content_items_to_text(content).as_deref() == Some("ancestor instructions") + ))); + assert_eq!(snapshot.retained_context(), Some(&expected_retained)); + } resumed.thread.shutdown_and_wait().await?; root.codex.shutdown_and_wait().await?; Ok(()) diff --git a/codex-rs/core/tests/suite/guardian_sender_messages_tests.rs b/codex-rs/core/tests/suite/guardian_sender_messages_tests.rs index ffef743326..f6f5073a7a 100644 --- a/codex-rs/core/tests/suite/guardian_sender_messages_tests.rs +++ b/codex-rs/core/tests/suite/guardian_sender_messages_tests.rs @@ -1,13 +1,21 @@ //! Genuine sender context stays reviewer-only and is replaced on every delivery. use anyhow::Result; +use codex_core::InheritedSessionId; +use codex_core::RestrictRootCapabilities; use codex_core::TurnInputRequest; use codex_core::config::Constrained; +use codex_features::Feature; use codex_protocol::config_types::ApprovalsReviewer; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::EventMsg; +use codex_protocol::protocol::SessionSource; +use codex_protocol::protocol::ThreadHistoryMode; use codex_protocol::turn_input::TurnInput; +use codex_protocol::user_input::UserInput; +use codex_thread_store::ForkBoundary; +use codex_thread_store::PrepareForkParams; use core_test_support::responses; use core_test_support::skip_if_no_network; use core_test_support::test_codex::test_codex; @@ -203,3 +211,108 @@ async fn guardian_receives_sender_user_messages_by_default( assert_eq!(requests.len(), 10); Ok(()) } + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn stored_fork_sender_evidence_matches_live_sender() -> Result<()> { + skip_if_no_network!(Ok(())); + let server = responses::start_mock_server().await; + let root = test_codex() + .with_history_mode(ThreadHistoryMode::Paginated) + .with_config(|config| { + config.features.enable(Feature::MultiAgentV2).unwrap(); + }) + .build_with_auto_env(&server) + .await?; + responses::mount_sse_once( + &server, + responses::sse(vec![responses::ev_completed("ancestor")]), + ) + .await; + root.submit_text_turn("ancestor evidence").await?; + root.codex.flush_rollout().await?; + let prepared = root + .thread_store + .prepare_fork(PrepareForkParams { + thread_id: root.session_configured.thread_id, + boundary: ForkBoundary::Latest, + }) + .await?; + let mut options = root.start_thread_options().await; + options.history_mode = Some(ThreadHistoryMode::Paginated); + options.session_source = Some(SessionSource::Custom("host".into())); + options + .thread_extension_init + .insert(InheritedSessionId(root.session_configured.session_id)); + options + .thread_extension_init + .insert(RestrictRootCapabilities); + let sender = root + .thread_manager + .fork_prepared_thread(options, prepared) + .await?; + responses::mount_sse_once( + &server, + responses::sse(vec![responses::ev_completed("sender")]), + ) + .await; + sender + .thread + .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text { + text: "B-local evidence".into(), + text_elements: Vec::new(), + }])) + .await?; + wait_for_event(&sender.thread, |event| { + matches!(event, EventMsg::TurnComplete(_)) + }) + .await; + sender.thread.flush_rollout().await?; + let remote = test_codex() + .with_thread_store(root.thread_store.clone()) + .with_history_mode(ThreadHistoryMode::Paginated) + .build_with_auto_env(&server) + .await?; + assert!( + remote + .thread_manager + .get_thread(sender.thread_id) + .await + .is_err() + ); + + for (index, receiver) in [&root.codex, &remote.codex].into_iter().enumerate() { + responses::mount_sse_once( + &server, + responses::sse(vec![responses::ev_completed("done")]), + ) + .await; + let sender_id = sender.thread_id; + let delivery: ResponseItem = serde_json::from_value(json!({ + "type": "function_call_output", "id": format!("delivery-{index}"), + "name": "send_message", "namespace": "cloud_threads", + "output": format!("{sender_id}Inspect."), + }))?; + receiver + .start_or_steer_turn(TurnInputRequest::new(TurnInput::ResponseItem(delivery))) + .await?; + wait_for_event(receiver, |event| matches!(event, EventMsg::TurnComplete(_))).await; + let history = receiver.conversation_history_snapshot().await; + let evidence = &history + .retained_context() + .expect("retained context") + .sender_user_messages() + .expect("sender evidence") + .text; + assert_eq!( + evidence + .lines() + .filter(|line| line.starts_with("user: ") || line.starts_with("assistant: ")) + .collect::>(), + vec!["user: B-local evidence"] + ); + } + sender.thread.shutdown_and_wait().await?; + root.codex.shutdown_and_wait().await?; + remote.codex.shutdown_and_wait().await?; + Ok(()) +}