Lightweight coding agent that runs in your terminal
Rust
Include sender user messages in Guardian delegation reviews (#46179)
jife269f2164cbb
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 06047f35fd..f046a7024c 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.rs b/codex-rs/core/src/agent/control.rsindex 33bd450b4c..4226e52bb8 100644--- a/codex-rs/core/src/agent/control.rs+++ b/codex-rs/core/src/agent/control.rs@@ -81,6 +81,7 @@ mod execution;mod interrupt;mod legacy;mod residency;+mod sender_context;mod service_tier;mod spawn;mod user_authorization;diff --git a/codex-rs/core/src/agent/control/sender_context.rs b/codex-rs/core/src/agent/control/sender_context.rsnew file mode 100644index 0000000000..c88fb33c97--- /dev/null+++ b/codex-rs/core/src/agent/control/sender_context.rs@@ -0,0 +1,83 @@+//! Captures genuine sender instructions for host-delivered task messages.+//! Only turn-input admission calls this, before queueing; ordinary tool results and+//! quoted delegation text cannot establish sender provenance. Lookup stays in this host.++use crate::context::ContextualUserFragment;+use crate::context::GuardianSenderMessages;+use codex_history::RetainedContextEntry;+use codex_history::RetainedContextOrder;+use codex_history::SenderUserMessages;+use codex_protocol::ThreadId;+use codex_protocol::models::ResponseItem;++use super::AgentControl;++impl AgentControl {+ pub(crate) async fn capture_sender_user_messages(+ &self,+ item: &ResponseItem,+ receiver_thread_id: ThreadId,+ receiver_turn_id: &str,+ ) -> Option<SenderUserMessages> {+ let ResponseItem::FunctionCallOutput {+ id: Some(id),+ call_id: None,+ name: Some(name),+ namespace: Some(namespace),+ output,+ ..+ } = item+ else {+ return None;+ };+ if !matches!(namespace.as_str(), "codex_app" | "codex_tui")+ || name != "send_message_to_thread"+ {+ return None;+ }+ // Recognized deliveries always get their own snapshot, even without usable provenance.+ let source_thread_id = output.body.to_text().and_then(|text| {+ let (source, input) = text+ .strip_prefix("<codex_delegation>\n <source_thread_id>")?+ .split_once("</source_thread_id>\n <input>")?;+ input.strip_suffix("</input>\n</codex_delegation>")?;+ ThreadId::from_string(source)+ .ok()+ .filter(|source| *source != receiver_thread_id)+ });+ let mut fragment = GuardianSenderMessages {+ source: source_thread_id,+ delivery: id.to_string(),+ messages: Vec::new(),+ };+ if let Some(source_thread_id) = source_thread_id+ && let Ok(manager) = self.upgrade()+ && let Ok(sender) = manager.get_thread(source_thread_id).await+ {+ let history = sender.conversation_history_snapshot().await;+ if let Some(context) = history.retained_context() {+ fragment.messages = context+ .ordered_entries()+ .filter_map(|(order, entry)| match (order, entry) {+ (+ RetainedContextOrder::Local(_),+ RetainedContextEntry::UserMessage(message),+ ) => Some(message.complete.then(|| message.text.clone())),+ (RetainedContextOrder::Inherited(_), _)+ | (_, RetainedContextEntry::VerifiedAnswer(_)) => None,+ })+ .rev()+ .take(/*n*/ 3)+ .collect();+ fragment.messages.reverse();+ }+ }+ let mut snapshot = SenderUserMessages {+ receiver_turn_id: receiver_turn_id.to_owned(),+ receiver_message_id: id.to_string(),+ text: fragment.render(),+ };+ snapshot.bound();+ Some(snapshot)+ }+}diff --git a/codex-rs/core/src/agent/control/spawn.rs b/codex-rs/core/src/agent/control/spawn.rsindex 4e8d9bff6e..67081ab737 100644--- a/codex-rs/core/src/agent/control/spawn.rs+++ b/codex-rs/core/src/agent/control/spawn.rs@@ -961,6 +961,11 @@ impl AgentControl {.get_or_insert_default().inherited_user_message = true;}+ if let Some(metadata) = &mut envelope.metadata+ && metadata.sender_user_messages.take().is_some()+ {+ metadata.user_input_order = None;+ }let response_item = &mut envelope.item;if matches!(response_item, ResponseItem::AgentMessage { .. }) {return false;diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rsindex c2bd787c5d..97d116b69e 100644--- a/codex-rs/core/src/agent/control_tests.rs+++ b/codex-rs/core/src/agent/control_tests.rs@@ -2202,15 +2202,36 @@ async fn spawn_agent_fork_strips_parent_usage_hints_from_compacted_history("type": "verified_answer", "turn_id": "parent-answer-turn", "call_id": "parent-answer-call","questions": [{"question": "Parent-local action?", "answer": "Parent only."}]})).expect("verified answer fixture");+ let delivery = codex_history::ResponseItemEnvelope {+ item: serde_json::from_value(serde_json::json!({+ "type": "function_call_output", "id": "parent-delivery",+ "name": "send_message_to_thread", "output": "Parent delivery"+ }))+ .unwrap(),+ metadata: Some(codex_history::CodexHarnessMetadata {+ user_input_order: Some(7),+ sender_user_messages: Some(Box::new(codex_history::SenderUserMessages {+ receiver_turn_id: "parent-turn".to_owned(),+ receiver_message_id: "parent-delivery".to_owned(),+ text: "Parent-only sender context".to_owned(),+ })),+ ..Default::default()+ }),+ };let mut retained_context = codex_history::RetainedContext::default();retained_context.record(&answer_event);+ retained_context.record_sender_user_messages(delivery.metadata.as_ref().unwrap());parent_thread.session.persist_rollout_items(&[RolloutItem::Compacted(CompactedItem {message: String::new(),replacement_history: Some(- replacement_history.into_iter().map(Into::into).collect(),+ replacement_history+ .into_iter()+ .map(Into::into)+ .chain([delivery.clone()])+ .collect(),),retained_context: Some(retained_context),guardian_history: Some(codex_history::GuardianHistoryCheckpoint(vec![@@ -2225,6 +2246,7 @@ async fn spawn_agent_fork_strips_parent_usage_hints_from_compacted_history(latest_token_usage_record: None,}),RolloutItem::RetainedContext(answer_event),+ RolloutItem::ResponseItem(delivery),RolloutItem::TurnContext(turn_context.to_turn_context_item()),rollout_response_item(spawn_agent_call(&parent_spawn_call_id)),])diff --git a/codex-rs/core/src/context/guardian_sender_messages.rs b/codex-rs/core/src/context/guardian_sender_messages.rsnew file mode 100644index 0000000000..620c31b36e--- /dev/null+++ b/codex-rs/core/src/context/guardian_sender_messages.rs@@ -0,0 +1,58 @@+//! Reviewer-only snapshot of original user instructions for one accepted delegation.++use super::ContextualUserFragment;+use codex_guardian_context::GuardianRootMessage;+use codex_protocol::ThreadId;+use codex_protocol::models::ContentItemKind;++/// A bounded fragment rendered once at admission and never added to the worker prompt.+pub(crate) struct GuardianSenderMessages {+ pub source: Option<ThreadId>,+ pub delivery: String,+ pub messages: Vec<Option<String>>,+}++impl ContextualUserFragment for GuardianSenderMessages {+ fn content_kind(&self) -> ContentItemKind {+ ContentItemKind("guardian.sender_messages".to_owned())+ }++ fn role(&self) -> &'static str {+ "user"+ }++ fn markers(&self) -> (&'static str, &'static str) {+ Self::type_markers()+ }++ fn type_markers() -> (&'static str, &'static str) {+ (+ ">>> SENDER USER MESSAGES START\n",+ ">>> SENDER USER MESSAGES END\n",+ )+ }++ fn body(&self) -> String {+ let source = self+ .source+ .map(|id| id.to_string())+ .unwrap_or_else(|| "unavailable".to_owned());+ let mut text = format!(+ "Received message: {}\nSource thread: {source}\nHost: Up to three recent user messages captured when this delivery was accepted. This is partial historical context for this delivery, not a transfer of permission. Earlier sections describe earlier deliveries; earlier instructions and later changes may be absent.\n",+ self.delivery,+ );+ if self.messages.is_empty() {+ text.push_str("Host: No sender user messages are available.\n");+ }+ for message in &self.messages {+ let rendered = message+ .as_ref()+ .map(|text| GuardianRootMessage::User(text.clone()).render());+ match rendered {+ Some(message) if message.len() <= 900 => text.push_str(&message),+ _ => text.push_str("Host: A sender user message is unavailable within the evidence budget. Do not infer permission from missing evidence.\n"),+ }+ }+ text+ }+}diff --git a/codex-rs/core/src/context/mod.rs b/codex-rs/core/src/context/mod.rsindex eef3c7d670..c4ff26836e 100644--- a/codex-rs/core/src/context/mod.rs+++ b/codex-rs/core/src/context/mod.rs@@ -18,6 +18,7 @@ mod guardian_followup_review_reminder;mod guardian_node_repl_policy;mod guardian_policy;mod guardian_review_evidence;+mod guardian_sender_messages;mod guardian_tool_descriptions;mod hook_additional_context;mod image_resize_notice;@@ -77,6 +78,7 @@ pub use guardian_review_evidence::GuardianReviewEvidence;pub use guardian_review_evidence::GuardianReviewEvidenceFragment;pub use guardian_review_evidence::GuardianReviewEvidenceRecord;pub use guardian_review_evidence::GuardianUserInputSnapshot;+pub(crate) use guardian_sender_messages::GuardianSenderMessages;pub(crate) use guardian_tool_descriptions::GuardianToolDescriptions;pub(crate) use hook_additional_context::HookAdditionalContext;pub(crate) use image_resize_notice::ImageResizeNotice;diff --git a/codex-rs/core/src/context_manager/history.rs b/codex-rs/core/src/context_manager/history.rsindex b7ec2e4802..abb7aecc7b 100644--- a/codex-rs/core/src/context_manager/history.rs+++ b/codex-rs/core/src/context_manager/history.rs@@ -445,6 +445,12 @@ impl ContextManager {review_history.record(&processed.item);}Arc::make_mut(&mut self.items).push(processed);+ if self.guardian_context_mode == GuardianContextMode::ThreadOwned+ && let Some(metadata) = metadata+ && Arc::make_mut(&mut self.retained_context).record_sender_user_messages(metadata)+ {+ self.user_message_revision = self.user_message_revision.saturating_add(1);+ }self.record_user_authorization(item,metadata,diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rsindex 4e276868ce..e3407cd1d6 100644--- a/codex-rs/core/src/hook_runtime.rs+++ b/codex-rs/core/src/hook_runtime.rs@@ -735,7 +735,7 @@ pub(crate) async fn record_pending_input(.await;}TurnInput::FunctionCallOutput(item) => {- sess.record_conversation_items(turn_context, model_info, std::slice::from_ref(&item))+ sess.record_annotated_conversation_items(turn_context, model_info, vec![item.clone()]).await;if let ResponseItem::FunctionCallOutput {id: Some(id),@@ -743,7 +743,7 @@ pub(crate) async fn record_pending_input(namespace,output,..- } = item+ } = item.item{let item = TurnItem::FunctionCallOutput(FunctionCallOutputItem {id: id.to_string(),diff --git a/codex-rs/core/src/session/input_queue.rs b/codex-rs/core/src/session/input_queue.rsindex 3efdb90b0c..ddd3038c8b 100644--- a/codex-rs/core/src/session/input_queue.rs+++ b/codex-rs/core/src/session/input_queue.rs@@ -26,7 +26,7 @@ pub enum TurnInput {#[serde(default, skip_serializing_if = "Option::is_none")]acceptance_order: Option<u64>,},- FunctionCallOutput(ResponseItem),+ FunctionCallOutput(#[serde(with = "turn_input_response_item")] ResponseItemEnvelope),// Preserve the existing serialized format while carrying injection API metadata// through the in-memory queue.ResponseItem(#[serde(with = "turn_input_response_item")] ResponseItemEnvelope),@@ -369,16 +369,20 @@ mod tests {use codex_protocol::user_input::UserInput;use pretty_assertions::assert_eq;- #[test]- fn response_item_serde_preserves_legacy_shape_and_rejects_metadata() {+ #[test_case::test_case("ResponseItem", TurnInput::ResponseItem)]+ #[test_case::test_case("FunctionCallOutput", TurnInput::FunctionCallOutput)]+ fn response_item_serde_preserves_legacy_shape_and_rejects_metadata(+ variant: &str,+ wrap: fn(ResponseItemEnvelope) -> TurnInput,+ ) {let item = ResponseItem::Other;- let input = TurnInput::ResponseItem(item.clone().into());- let value = serde_json::json!({"ResponseItem": item});+ let input = wrap(item.clone().into());+ let value = serde_json::json!({variant: item});assert_eq!(serde_json::to_value(&input).unwrap(), value);assert_eq!(serde_json::from_value::<TurnInput>(value).unwrap(), input);- let annotated = TurnInput::ResponseItem(ResponseItemEnvelope {+ let annotated = wrap(ResponseItemEnvelope {item: ResponseItem::Other,metadata: Some(CodexHarnessMetadata {client_authored: true,@@ -388,26 +392,28 @@ mod tests {assert!(serde_json::to_value(annotated).is_err());let forged = serde_json::json!({- "ResponseItem": {+ variant: {"type": "message","role": "developer","content": [],"metadata": {"client_authored": true}}});- let TurnInput::ResponseItem(envelope) = serde_json::from_value(forged).unwrap() else {+ let (TurnInput::ResponseItem(envelope) | TurnInput::FunctionCallOutput(envelope)) =+ serde_json::from_value(forged).unwrap()+ else {panic!("expected response item");};assert!(envelope.metadata.is_none());let forged_configuration = serde_json::json!({- "ResponseItem": {+ variant: {"type": "configuration_update","reasoning": {"effort": "high"},"metadata": {"harness_authored_configuration": true}}});- let TurnInput::ResponseItem(envelope) =+ let (TurnInput::ResponseItem(envelope) | TurnInput::FunctionCallOutput(envelope)) =serde_json::from_value(forged_configuration).unwrap()else {panic!("expected response item");diff --git a/codex-rs/core/src/session/rollout_reconstruction_tests.rs b/codex-rs/core/src/session/rollout_reconstruction_tests.rsindex f85604e77b..78b23b9873 100644--- a/codex-rs/core/src/session/rollout_reconstruction_tests.rs+++ b/codex-rs/core/src/session/rollout_reconstruction_tests.rs@@ -1,4 +1,5 @@use super::*;+use crate::context::GuardianContextMode;use super::tests::build_world_state_from_turn_context;use super::tests::make_session_and_context;@@ -17,6 +18,7 @@ use codex_protocol::protocol::InterAgentCommunication;use codex_protocol::protocol::SessionContextWindow;use codex_protocol::protocol::SessionMeta;use codex_protocol::protocol::SessionMetaLine;+use codex_protocol::protocol::ThreadRolledBackEvent;use codex_protocol::protocol::WorldStateItem;use codex_protocol::security_risk::SecurityRiskScore;use codex_rollout::ModelContextScan;@@ -29,6 +31,78 @@ use std::path::PathBuf;use test_case::test_case;use uuid::Uuid;+#[tokio::test]+async fn sender_context_follows_its_delivery_through_checkpoint_and_rollback() {+ let (mut session, turn_context) = make_session_and_context().await;+ session.guardian_context_mode = GuardianContextMode::ThreadOwned;+ let mut live = ContextManager::with_guardian_context_mode(+ GuardianContextMode::ThreadOwned,+ &SessionSource::default(),+ );+ let mut items = Vec::new();+ let mut snapshots = Vec::new();+ for index in 0..2 {+ // A and then B are accepted before either is consumed.+ let acceptance_order = Some(live.reserve_input_order());+ let steer_order = Some(live.reserve_input_order());+ let snapshot = codex_history::SenderUserMessages {+ receiver_turn_id: format!("turn-{index}"),+ receiver_message_id: format!("delivery-{index}"),+ text: format!("Sender context {index}"),+ };+ let input = [+ ResponseItemEnvelope {+ item: serde_json::from_value::<ResponseItem>(json!({+ "type": "function_call_output", "id": snapshot.receiver_message_id,+ "name": "send_message_to_thread", "namespace": "codex_app", "output": "Inspect."+ }))+ .unwrap(),+ metadata: Some(codex_history::CodexHarnessMetadata {+ user_input_order: acceptance_order,+ sender_user_messages: Some(Box::new(snapshot.clone())),+ ..Default::default()+ }),+ },+ ResponseItemEnvelope {+ item: user_message("Later user steer B."),+ metadata: Some(codex_history::CodexHarnessMetadata {+ user_input_order: steer_order,+ ..Default::default()+ }),+ },+ ];+ live.record_annotated_items(&input, turn_context.model_info().truncation_policy.into());+ items.extend(input.into_iter().map(RolloutItem::ResponseItem));+ snapshots.push(snapshot);+ }+ let mut checkpoint: CompactedItem =+ serde_json::from_value(json!({"message": "compacted"})).unwrap();+ checkpoint.replacement_history = Some(live.annotated_items().to_vec());+ checkpoint.retained_context = Some(live.retained_context().clone());+ let mut checkpointed = items.clone();+ checkpointed.push(RolloutItem::Compacted(checkpoint));+ for (num_turns, expected) in [(1, &snapshots[1]), (2, &snapshots[0])] {+ let mut rolled_back = live.clone();+ rolled_back.drop_last_n_user_turns(num_turns);+ assert_eq!(+ rolled_back.retained_context().sender_user_messages(),+ Some(expected)+ );+ for history in [items.clone(), checkpointed.clone()] {+ let mut history: Vec<RolloutItem> =+ serde_json::from_value(serde_json::to_value(history).unwrap()).unwrap();+ history.push(RolloutItem::EventMsg(EventMsg::ThreadRolledBack(+ ThreadRolledBackEvent { num_turns },+ )));+ let replayed = session+ .reconstruct_history_from_rollout(&turn_context, &history)+ .await;+ assert_eq!(replayed.retained_context, *rolled_back.retained_context());+ assert_eq!(replayed.history, rolled_back.annotated_items());+ }+ }+}+macro_rules! object {($value:tt) => {serde_json::from_value(json!($value)).unwrap()diff --git a/codex-rs/core/src/session/turn_input.rs b/codex-rs/core/src/session/turn_input.rsindex ba366c67e1..b382878997 100644--- a/codex-rs/core/src/session/turn_input.rs+++ b/codex-rs/core/src/session/turn_input.rs@@ -18,9 +18,12 @@ use super::session::SessionSettingsUpdate;use super::thread_settings;use super::turn_context::NewTurnContextOptions;use super::turn_context::TurnContext;+use crate::context::GuardianContextMode;use crate::state::ActiveTurn;use crate::state::TurnState;use crate::tasks::RegularTask;+use codex_history::CodexHarnessMetadata;+use codex_history::ResponseItemEnvelope;use codex_protocol::config_types::ModeKind;use codex_protocol::error::CodexErr;use codex_protocol::error::Result as CodexResult;@@ -353,7 +356,7 @@ async fn start_or_steer(}let mut task_input = merge_additional_context_input(session, additional_context).await;if has_explicit_input {- task_input.push(pending_turn_input(session, input).await);+ task_input.push(pending_turn_input(session, input, &turn_context.sub_id).await);}session.spawn_task(turn_context, task_input, RegularTask::new())@@ -486,7 +489,7 @@ async fn start_if_idle(if let SubmittedTurnInput::UserInput { content, .. } = &input {turn_context.session_telemetry.user_prompt(content);}- task_input.push(pending_turn_input(session, input).await);+ task_input.push(pending_turn_input(session, input, &turn_context.sub_id).await);}TurnStartKind::Automatic | TurnStartKind::Recovery => {// Empty automatic user input resumes sampling without a new message.@@ -495,7 +498,7 @@ async fn start_if_idle(.input_queue.extend_pending_input_for_turn_state(turn_state.as_ref(),- vec![pending_turn_input(session, input).await],+ vec![pending_turn_input(session, input, &turn_context.sub_id).await],).await;}@@ -691,7 +694,7 @@ impl Session {acceptance_order: self.reserve_user_input_order().await,}}- input => pending_turn_input(self, input.clone()).await,+ input => pending_turn_input(self, input.clone(), active_turn_id).await,};pending_input.push(input);self.input_queue@@ -719,7 +722,11 @@ async fn merge_additional_context_input(.collect()}-async fn pending_turn_input(session: &Session, input: SubmittedTurnInput) -> TurnInput {+async fn pending_turn_input(+ session: &Session,+ input: SubmittedTurnInput,+ turn_id: &str,+) -> TurnInput {match input {SubmittedTurnInput::UserInput { content, client_id } => TurnInput::UserInput {content,@@ -733,7 +740,22 @@ async fn pending_turn_input(session: &Session, input: SubmittedTurnInput) -> Tur) =>{Session::assign_missing_response_item_id(&mut item);- TurnInput::FunctionCallOutput(item)+ let metadata = if session.guardian_context_mode == GuardianContextMode::ThreadOwned+ && let Some(messages) = session+ .services+ .agent_control+ .capture_sender_user_messages(&item, session.thread_id, turn_id)+ .await+ {+ Some(CodexHarnessMetadata {+ user_input_order: session.reserve_user_input_order().await,+ sender_user_messages: Some(Box::new(messages)),+ ..Default::default()+ })+ } else {+ None+ };+ TurnInput::FunctionCallOutput(ResponseItemEnvelope { item, metadata })}SubmittedTurnInput::ResponseItem(item) => TurnInput::ResponseItem(item.into()),SubmittedTurnInput::InterAgentCommunication(communication) => {diff --git a/codex-rs/core/tests/suite/guardian_sender_messages_tests.rs b/codex-rs/core/tests/suite/guardian_sender_messages_tests.rsnew file mode 100644index 0000000000..9d5f348a28--- /dev/null+++ b/codex-rs/core/tests/suite/guardian_sender_messages_tests.rs@@ -0,0 +1,163 @@+//! Genuine sender context stays reviewer-only and is replaced on every delivery.++use anyhow::Result;+use codex_core::StartThreadOptions;+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::turn_input::TurnInput;+use core_test_support::responses;+use core_test_support::skip_if_no_network;+use core_test_support::test_codex::test_codex;+use core_test_support::wait_for_event;+use pretty_assertions::assert_eq;+use serde_json::json;++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn guardian_receives_sender_user_messages() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let test = test_codex()+ .with_model_info_override("gpt-5.5", |model| {+ model.auto_review_model_override = Some("gpt-5.6-luna".to_owned());+ })+ .with_config(|config| {+ config+ .features+ .enable(Feature::GuardianThreadContext)+ .unwrap();+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ })+ .build_with_auto_env(&server)+ .await?;+ let sender = test.session_configured.thread_id;+ let receiver = test+ .thread_manager+ .start_thread(StartThreadOptions {+ environments: Some(test.codex.environment_selections().await),+ ..StartThreadOptions::new(test.config.clone())+ })+ .await?+ .thread;+ let done = || responses::sse(vec![responses::ev_completed("done")]);+ let mut requests = Vec::new();+ for prompt in [+ "OLDEST",+ "Inspect the experiment.",+ "Add twenty workers.",+ "Only use staging.\nNever production.",+ ] {+ let mock = responses::mount_sse_once(&server, done()).await;+ test.submit_text_turn(prompt).await?;+ requests.extend(mock.requests());+ }+ for (namespace, output, expected) in [+ (+ "codex_app",+ format!(+ "<codex_delegation>\n <source_thread_id>{sender}</source_thread_id>\n <input>Inspect.</input>\n</codex_delegation>"+ ),+ vec![+ "user: Inspect the experiment.",+ "user: Add twenty workers.",+ "user: Only use staging.",+ "user: Never production.",+ ],+ ),+ (+ "codex_tui",+ "Inspect again without sender provenance.".to_owned(),+ vec![],+ ),+ ] {+ let command = json!({+ "cmd": "exit 0",+ "sandbox_permissions": "require_escalated",+ "justification": "Inspect the staging experiment.",+ })+ .to_string();+ let mock = responses::mount_sse_sequence(+ &server,+ vec![+ responses::sse(vec![+ responses::ev_function_call("inspect", "exec_command", &command),+ responses::ev_completed("action"),+ ]),+ responses::sse(vec![+ responses::ev_assistant_message(+ "decision",+ r#"{"risk_level":"high","user_authorization":"unknown","outcome":"deny"}"#,+ ),+ responses::ev_completed("review"),+ ]),+ done(),+ ],+ )+ .await;+ let delivery: ResponseItem = serde_json::from_value(json!({+ "type": "function_call_output",+ "id": format!("delivery-{namespace}"),+ "name": "send_message_to_thread",+ "namespace": namespace,+ "output": output,+ }))?;+ receiver+ .start_or_steer_turn(TurnInputRequest::new(TurnInput::ResponseItem(delivery)))+ .await?;+ wait_for_event(&receiver, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ let captured = mock.requests();+ assert_eq!(captured.len(), 3);+ // The delegated agent receives the tool output; only Guardian sees original user text.+ assert!(+ !captured[0]+ .body_json()+ .to_string()+ .contains("Add twenty workers.")+ );+ let review_body = captured[1].body_json();+ let review = review_body["input"]+ .as_array()+ .unwrap()+ .iter()+ .filter_map(|item| item["content"].as_array())+ .flatten()+ .filter_map(|item| item["text"].as_str())+ .collect::<String>();+ assert!(review.contains("SENDER USER MESSAGES START"));+ let history = receiver.conversation_history_snapshot().await;+ let snapshot = history+ .retained_context()+ .unwrap()+ .sender_user_messages()+ .unwrap();+ assert_eq!(+ snapshot+ .text+ .lines()+ .filter(|line| line.starts_with("user: "))+ .collect::<Vec<_>>(),+ expected+ );+ let start = ">>> SENDER USER MESSAGES START\n";+ let end = ">>> SENDER USER MESSAGES END\n";+ let current = review+ .rsplit_once(start)+ .unwrap()+ .1+ .split(end)+ .next()+ .unwrap();+ assert_eq!(format!("{start}{current}{end}"), snapshot.text);+ requests.extend(captured);+ }+ assert_eq!(requests.len(), 10);+ Ok(())+}diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rsindex 973de946c0..acea3ca06a 100644--- a/codex-rs/core/tests/suite/mod.rs+++ b/codex-rs/core/tests/suite/mod.rs@@ -217,3 +217,6 @@ mod window_headers;mod windows_sandbox;mod workspace_roots;mod worktree_trust;++#[path = "guardian_sender_messages_tests.rs"]+mod guardian_sender_messages;diff --git a/codex-rs/guardian-context/src/composition.rs b/codex-rs/guardian-context/src/composition.rsindex 25450d989d..9518409be5 100644--- a/codex-rs/guardian-context/src/composition.rs+++ b/codex-rs/guardian-context/src/composition.rs@@ -136,6 +136,9 @@ impl CollectedContext {ContextSection::RootConversation { items } => {(4, "root_conversation", text_content(items))}+ ContextSection::SenderUserMessages { items } => {+ (4, "sender_user_messages", text_content(items))+ }ContextSection::RetainedUserInstructions { items } => {(5, "retained_user_instructions", text_content(items))}diff --git a/codex-rs/guardian-context/src/composition_tests.rs b/codex-rs/guardian-context/src/composition_tests.rsindex ed0fdf41c1..6bf0a17f53 100644--- a/codex-rs/guardian-context/src/composition_tests.rs+++ b/codex-rs/guardian-context/src/composition_tests.rs@@ -116,3 +116,78 @@ fn long_text_and_file_image_delivery_is_lossless_bounded_and_fully_budgeted() {});assert_eq!(context.into_user_inputs().unwrap(), expected_inputs);}++#[test]+fn sender_restrictions_survive_budget_trimming_for_both_reviewers() {+ for presentation in [+ ContextPresentation::SyncFull {+ session_id: "receiver",+ },+ ContextPresentation::SyncDelta {+ session_id: "receiver",+ },+ ContextPresentation::Async,+ ] {+ let sender = vec!["user: Only use the staging pool.\n".to_owned()];+ let context = CollectedContext {+ sections: vec![+ ContextSection::SenderUserMessages {+ items: sender.clone(),+ },+ ContextSection::ConversationTranscript { items: Vec::new() },+ ],+ }+ .compose(+ presentation,+ RenderedTranscript {+ items: vec![Budgeted::optional(+ "old tool output ".repeat(/*n*/ 2_000),+ BudgetPriority::Tool,+ )],+ omission_note: None,+ truncations: Vec::new(),+ },+ )+ .unwrap();+ let selected = context+ .clone()+ .enforce_budget(+ crate::RequestBudget {+ max_input_tokens: 1_000,+ existing_context_tokens: 0,+ },+ "evidence omitted".to_owned(),+ crate::HistoryTruncation::Allow,+ )+ .unwrap();+ assert!(selected.estimated_tokens() <= 1_000);+ assert_eq!(selected.truncations.len(), 1);+ let sender_section = selected+ .sections+ .into_iter()+ .find(|section| section.id == "sender_user_messages")+ .unwrap();+ let SectionDelivery::UserContent(items) = sender_section.delivery else {+ panic!("sender context must remain user evidence");+ };+ assert_eq!(+ items,+ vec![Budgeted::required(ContentItem::InputText {+ text: sender[0].clone()+ })]+ );+ assert!(matches!(+ context.enforce_budget(+ crate::RequestBudget {+ max_input_tokens: 1,+ existing_context_tokens: 0+ },+ "evidence omitted".to_owned(),+ crate::HistoryTruncation::Allow,+ ),+ Err(SectionError::EvidenceLimitExceeded {+ section: "request_budget"+ })+ ));+ }+}diff --git a/codex-rs/guardian-context/src/lib.rs b/codex-rs/guardian-context/src/lib.rsindex 36bce55ae1..093e8bb093 100644--- a/codex-rs/guardian-context/src/lib.rs+++ b/codex-rs/guardian-context/src/lib.rs@@ -18,6 +18,7 @@ use codex_protocol::models::ResponseItem;use authorization::RootConversationSection;use authorization::TrustedUserAnswersSection;use retained_instructions::RetainedUserInstructionsSection;+use sender_user_messages::SenderUserMessagesSection;use transcript::ConversationTranscriptSection;pub use action::ActionPresentation;@@ -44,6 +45,7 @@ pub use verified_answers::render_verified_answer;pub use verified_answers::render_verified_answers;mod retained_instructions;+mod sender_user_messages;mod action;mod enforcement;@@ -254,6 +256,7 @@ pub fn default_registry() -> &'static SectionRegistry {registry.register(trusted_tool::TrustedToolSection);registry.register(trusted_skills::TrustedSkillsSection);registry.register(RootConversationSection);+ registry.register(SenderUserMessagesSection);registry.register(RetainedUserInstructionsSection);registry.register(TrustedUserAnswersSection);registry.register(ConversationTranscriptSection);diff --git a/codex-rs/guardian-context/src/section.rs b/codex-rs/guardian-context/src/section.rsindex 68a2835ccc..8b7e0926fa 100644--- a/codex-rs/guardian-context/src/section.rs+++ b/codex-rs/guardian-context/src/section.rs@@ -21,6 +21,7 @@ pub enum ContextSection<T = ConversationTranscriptEntry> {RootConversation { items: Vec<String> },TrustedUserAnswers { items: Vec<String> },RetainedUserInstructions { items: Vec<String> },+ SenderUserMessages { items: Vec<String> },PlannedAction(PlannedAction),PreviousReviews(PreviousReviews),TrustedTool(TrustedTool),diff --git a/codex-rs/guardian-context/src/sender_user_messages.rs b/codex-rs/guardian-context/src/sender_user_messages.rsnew file mode 100644index 0000000000..63c1e79529--- /dev/null+++ b/codex-rs/guardian-context/src/sender_user_messages.rs@@ -0,0 +1,27 @@+//! Both reviewers consume the same host-rendered, delivery-bound sender evidence.++use codex_history::RetainedContext;++use crate::ContextSection;+use crate::SectionContributor;+use crate::SectionError;+use crate::SectionInput;+use crate::SectionScope;++pub(crate) struct SenderUserMessagesSection;++impl SectionContributor for SenderUserMessagesSection {+ fn scope(&self) -> SectionScope {+ SectionScope::Shared+ }++ fn contribute(&self, input: &SectionInput<'_>) -> Result<Option<ContextSection>, SectionError> {+ Ok(input+ .history+ .retained_context()+ .and_then(RetainedContext::sender_user_messages)+ .map(|snapshot| ContextSection::SenderUserMessages {+ items: vec![snapshot.text.clone()],+ }))+ }+}diff --git a/codex-rs/history/src/lib.rs b/codex-rs/history/src/lib.rsindex efdb518b4b..65564e76b6 100644--- a/codex-rs/history/src/lib.rs+++ b/codex-rs/history/src/lib.rs@@ -77,6 +77,10 @@ pub struct CodexHarnessMetadata {/// Copied parent context stays model-visible but must not become child-local authorization.#[serde(default, skip_serializing_if = "std::ops::Not::not")]pub inherited_user_message: bool,++ /// Sender context captured by the host when this task message was accepted.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub sender_user_messages: Option<Box<SenderUserMessages>>,}impl ResponseItemEnvelope {@@ -175,6 +179,9 @@ impl JsonSchema for RolloutItem {mod guardian_history;mod reconciled_retained_context;mod retained_context;+mod sender_user_messages;++pub use sender_user_messages::SenderUserMessages;pub use reconciled_retained_context::ReconciledRetainedContext;pub use retained_context::RetainedContext;diff --git a/codex-rs/history/src/retained_context.rs b/codex-rs/history/src/retained_context.rsindex ecc5c364c9..1e9379f68f 100644--- a/codex-rs/history/src/retained_context.rs+++ b/codex-rs/history/src/retained_context.rs@@ -11,6 +11,7 @@ use serde::Serialize;use crate::CodexHarnessMetadata;use crate::ResponseItemEnvelope;+use crate::SenderUserMessages;const MAX_FAMILY_RECORDS: usize = 8;const MAX_RECORD_BYTES: usize = 16_384;@@ -149,6 +150,9 @@ pub struct RetainedContext {user_messages_incomplete: bool,#[serde(default)]next_order: u64,+ /// Delivery snapshots share local input order, so later steers can be undone independently.+ #[serde(default, skip_serializing_if = "VecDeque::is_empty")]+ sender_deliveries: VecDeque<Ordered<SenderUserMessages>>,}fn legacy_user_messages_incomplete() -> bool {@@ -202,6 +206,35 @@ impl RetainedContextEvent {}impl RetainedContext {+ /// Context for the latest delivery still present in this task's retained history.+ pub fn sender_user_messages(&self) -> Option<&SenderUserMessages> {+ self.sender_deliveries.back().map(|entry| &entry.value)+ }++ /// Retains host metadata with the delivery's acceptance order, including during replay.+ pub fn record_sender_user_messages(&mut self, metadata: &CodexHarnessMetadata) -> bool {+ let Some(messages) = metadata.sender_user_messages.as_deref() else {+ return false;+ };+ if self+ .sender_deliveries+ .iter()+ .any(|entry| entry.value.receiver_message_id == messages.receiver_message_id)+ {+ return false;+ }+ let mut messages = messages.clone();+ messages.bound();+ let order = self.record_order(metadata.user_input_order);+ self.sender_deliveries.push_back(Ordered {+ inherited: false,+ order,+ value: messages,+ });+ bound_family(&mut self.sender_deliveries, /*incomplete*/ &mut false);+ true+ }+/// Reserves order without retaining pending input that hooks may reject or cancel.pub fn reserve_order(&mut self) -> u64 {let order = self.next_order;@@ -396,6 +429,17 @@ impl RetainedContext {self.next_order = self.next_order.max(entry.order.saturating_add(1));}}+ for entry in &mut self.sender_deliveries {+ entry.value.bound();+ self.next_order = self.next_order.max(entry.order.saturating_add(1));+ }+ bound_family(&mut self.sender_deliveries, /*incomplete*/ &mut false);+ for metadata in surviving_items+ .iter()+ .filter_map(|item| item.metadata.as_ref())+ {+ self.record_sender_user_messages(metadata);+ }for order in surviving_items.iter().filter_map(|item| item.metadata.as_ref())@@ -435,6 +479,8 @@ impl RetainedContext {.map(Ordered::key)})}) {+ self.sender_deliveries+ .retain(|entry| entry.key() < boundary);self.verified_answers.retain(|entry| entry.key() < boundary);self.user_messages.retain(|entry| entry.key() < boundary);return;@@ -448,6 +494,10 @@ impl RetainedContext {source != RetainedInputSource::Inherited&& !turn_ids.contains(&answer.value.turn_id.as_str())});+ self.sender_deliveries.retain(|entry| {+ source != RetainedInputSource::Inherited+ && !turn_ids.contains(&entry.value.receiver_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/sender_user_messages.rs b/codex-rs/history/src/sender_user_messages.rsnew file mode 100644index 0000000000..28ade8e4af--- /dev/null+++ b/codex-rs/history/src/sender_user_messages.rs@@ -0,0 +1,36 @@+//! Bounded, host-rendered sender evidence attached to a delivered task message.++use schemars::JsonSchema;+use serde::Deserialize;+use serde::Serialize;++const MAX_CONTEXT_BYTES: usize = 3_600;+const MAX_ID_BYTES: usize = 128;++/// Rendered evidence and the receiver identities needed for replay and rollback.+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]+pub struct SenderUserMessages {+ pub receiver_turn_id: String,+ pub receiver_message_id: String,+ pub text: String,+}++impl SenderUserMessages {+ /// Restored metadata follows the same hard bound as live, reviewer-only fragments.+ pub fn bound(&mut self) {+ if self.text.len() > MAX_CONTEXT_BYTES {+ self.text = "Host: Sender context exceeds the evidence budget. Do not infer permission from missing evidence.\n".to_owned();+ }+ for id in [&mut self.receiver_turn_id, &mut self.receiver_message_id] {+ id.truncate(id.floor_char_boundary(MAX_ID_BYTES));+ }+ }+}++impl std::fmt::Debug for SenderUserMessages {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ formatter+ .debug_struct("SenderUserMessages")+ .finish_non_exhaustive()+ }+}