Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Remove legacy Guardian authorization evidence paths (#47688)

felixxia-oai1d516d8b3d3b
diff --git a/codex-rs/core/src/agent/control/user_authorization.rs b/codex-rs/core/src/agent/control/user_authorization.rs
index 7d0826e8f5..708c673723 100644
--- a/codex-rs/core/src/agent/control/user_authorization.rs
+++ b/codex-rs/core/src/agent/control/user_authorization.rs
@@ -1,7 +1,7 @@
-//! Projects bounded root evidence for worker reviewers using the session's capture policy.
+//! Projects bounded retained root evidence for worker reviewers.
//! Retained root instructions stay authoritative while old checkpoints use legacy review.
//! User evidence wins, then assistant context preceding ordinary replies, then other live evidence.
-//! Thread-owned recovery includes commentary; legacy projection keeps its phase filter.
+//! Recovery includes commentary and confirmed messaging context.
//! Projection limits do not change authorization completeness; unavailable source text does.
//! Retained-history reconciliation owns recovery order and missing-instruction provenance.
//! Known positions preserve host order, not delivery order or inferred question-answer pairs.
@@ -15,7 +15,6 @@ use super::LocalAgentControl;
use crate::codex_thread::GuardianRootMessage;
use crate::codex_thread::GuardianRootSnapshot;
use crate::compact::is_summary_message;
-use crate::context::GuardianContextMode;
use crate::context::GuardianReviewEvidence;
use crate::context::is_contextual_user_fragment;
use crate::event_mapping::parse_turn_item;
@@ -30,7 +29,6 @@ use codex_protocol::ThreadId;
use codex_protocol::items::AgentMessageContent;
use codex_protocol::items::TurnItem;
use codex_protocol::models::ContentItem;
-use codex_protocol::models::MessagePhase;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::MultiAgentVersion;
@@ -85,78 +83,70 @@ impl LocalAgentControl {
.services
.thread_extension_data
.get_or_init(GuardianReviewEvidence::default);
- let context_mode = root_thread.session.guardian_context_mode;
let mut latest_user_turn_id = None;
- let (messages, authorization_version) = if context_mode == GuardianContextMode::ThreadOwned
- {
- let retained_context = root_history.retained_context();
- let reconciled = ReconciledRetainedContext::new(
- Some(retained_context),
- root_history
- .annotated_items()
- .iter()
- .filter_map(|envelope| {
- let item = &envelope.item;
- let Some(TurnItem::UserMessage(message)) = parse_turn_item(item) else {
- return None;
- };
- let text = message.message();
- if is_summary_message(&text)
- || text.trim_start().starts_with("<user_action>")
- {
+ let retained_context = root_history.retained_context();
+ let reconciled = ReconciledRetainedContext::new(
+ Some(retained_context),
+ root_history
+ .annotated_items()
+ .iter()
+ .filter_map(|envelope| {
+ let item = &envelope.item;
+ let Some(TurnItem::UserMessage(message)) = parse_turn_item(item) else {
+ return None;
+ };
+ let text = message.message();
+ if is_summary_message(&text) || text.trim_start().starts_with("<user_action>") {
+ return None;
+ }
+ let order = envelope
+ .metadata
+ .as_ref()
+ .filter(|metadata| !metadata.inherited_user_message)
+ .and_then(|metadata| metadata.user_input_order);
+ Some((
+ order,
+ RetainedUserMessage {
+ turn_id: item.turn_id().unwrap_or_default().to_owned(),
+ message_id: item.id().map(|id| id.as_str().to_owned()),
+ text,
+ complete: false,
+ },
+ ))
+ }),
+ );
+ let mut missing_root_instructions = reconciled.missing_user_messages;
+ let mut messages = reconciled
+ .ordered_entries()
+ .filter_map(|(order, entry)| match entry {
+ RetainedContextEntry::UserMessage(message) => {
+ let text = if message.text.is_empty() && !message.complete {
+ // Older records may omit a large instruction. Recover that exact
+ // source while it remains available in the parent context.
+ let original = message.message_id.as_deref().and_then(|id| {
+ root_history
+ .raw_items()
+ .chain(root_history.guardian_history_items().into_iter().flatten())
+ .find(|item| {
+ item.id().is_some_and(|item_id| item_id.as_str() == id)
+ })
+ });
+ let Some(TurnItem::UserMessage(original)) =
+ original.and_then(parse_turn_item)
+ else {
+ missing_root_instructions = true;
return None;
- }
- let order = envelope
- .metadata
- .as_ref()
- .filter(|metadata| !metadata.inherited_user_message)
- .and_then(|metadata| metadata.user_input_order);
- Some((
- order,
- RetainedUserMessage {
- turn_id: item.turn_id().unwrap_or_default().to_owned(),
- message_id: item.id().map(|id| id.as_str().to_owned()),
- text,
- complete: false,
- },
- ))
- }),
- );
- let mut missing_root_instructions = reconciled.missing_user_messages;
- let mut messages = reconciled
- .ordered_entries()
- .filter_map(|(order, entry)| match entry {
- RetainedContextEntry::UserMessage(message) => {
- let text = if message.text.is_empty() && !message.complete {
- // Older records may omit a large instruction. Recover that exact
- // source while it remains available in the parent context.
- let original = message.message_id.as_deref().and_then(|id| {
- root_history
- .raw_items()
- .chain(
- root_history.guardian_history_items().into_iter().flatten(),
- )
- .find(|item| {
- item.id().is_some_and(|item_id| item_id.as_str() == id)
- })
- });
- let Some(TurnItem::UserMessage(original)) =
- original.and_then(parse_turn_item)
- else {
- missing_root_instructions = true;
- return None;
- };
- Cow::Owned(original.message())
- } else {
- Cow::Borrowed(message.text.as_str())
};
- if is_contextual_user_fragment(&ContentItem::InputText {
- text: text.to_string(),
- }) {
- return None;
- }
- (!is_summary_message(&text)
- && !text.trim_start().starts_with("<user_action>"))
+ Cow::Owned(original.message())
+ } else {
+ Cow::Borrowed(message.text.as_str())
+ };
+ if is_contextual_user_fragment(&ContentItem::InputText {
+ text: text.to_string(),
+ }) {
+ return None;
+ }
+ (!is_summary_message(&text) && !text.trim_start().starts_with("<user_action>"))
.then(|| {
latest_user_turn_id = Some(message.turn_id.clone());
(
@@ -167,197 +157,154 @@ impl LocalAgentControl {
),
)
})
- }
- RetainedContextEntry::VerifiedAnswer(answer) => {
- codex_guardian_context::render_verified_answer(answer)
- .map(|text| (Some(order), GuardianRootMessage::UserInput(text)))
- }
- RetainedContextEntry::AssistantMessage(_) => None,
- })
- .collect::<Vec<_>>();
- messages.drain(..messages.len().saturating_sub(MAX_ROOT_MESSAGES));
- // Old opt-out checkpoints have genuine instructions but no retained source order.
- // Keep them separately bounded and explicitly unordered; never replace newer facts.
- let mut legacy_messages = VecDeque::new();
- let legacy_capacity = MAX_ROOT_MESSAGES.saturating_sub(messages.len());
- if missing_root_instructions && legacy_capacity > 0 {
- let mut latest_legacy_turn_id = None;
- for message in
- reconciled.unmatched_user_messages(root_history.legacy_user_messages())
- {
- latest_legacy_turn_id =
- (!message.turn_id.is_empty()).then_some(message.turn_id);
- legacy_messages.push_back(GuardianRootMessage::User(message.text));
- if legacy_messages.len() > legacy_capacity {
- legacy_messages.pop_front();
- }
}
- if latest_user_turn_id.is_none() {
- latest_user_turn_id = latest_legacy_turn_id;
+ RetainedContextEntry::VerifiedAnswer(answer) => {
+ codex_guardian_context::render_verified_answer(answer)
+ .map(|text| (Some(order), GuardianRootMessage::UserInput(text)))
+ }
+ RetainedContextEntry::AssistantMessage(_) => None,
+ })
+ .collect::<Vec<_>>();
+ messages.drain(..messages.len().saturating_sub(MAX_ROOT_MESSAGES));
+ // Old opt-out checkpoints have genuine instructions but no retained source order.
+ // Keep them separately bounded and explicitly unordered; never replace newer facts.
+ let mut legacy_messages = VecDeque::new();
+ let legacy_capacity = MAX_ROOT_MESSAGES.saturating_sub(messages.len());
+ if missing_root_instructions && legacy_capacity > 0 {
+ let mut latest_legacy_turn_id = None;
+ for message in reconciled.unmatched_user_messages(root_history.legacy_user_messages()) {
+ latest_legacy_turn_id = (!message.turn_id.is_empty()).then_some(message.turn_id);
+ legacy_messages.push_back(GuardianRootMessage::User(message.text));
+ if legacy_messages.len() > legacy_capacity {
+ legacy_messages.pop_front();
}
}
- let mut missing_assistant_context = retained_context.has_omitted_assistant_messages();
- // Prefer a renderable retained original over a shortened checkpoint copy.
- // Otherwise preserve the bounded live evidence, including confirmed messaging sends.
- let live_assistant_messages = root_history
- .annotated_items()
- .iter()
- .filter(|envelope| {
- !envelope
- .metadata
- .as_ref()
- .is_some_and(|metadata| metadata.compaction_output)
- })
- .filter_map(|envelope| {
- let text = root_assistant_text(&envelope.item, &delivered_messages)?;
- let id = envelope
- .item
- .id()
- .map(codex_protocol::ResponseItemId::as_str);
- let retained = reconciled.ordered_entries().find_map(|(order, entry)| {
- let RetainedContextEntry::AssistantMessage(message) = entry else {
- return None;
- };
- id.filter(|id| message.message_id.as_deref() == Some(*id))
- .map(|_| (order, message))
- });
- if let Some((order, message)) = retained
- && let Some(message) =
- codex_guardian_context::retained_assistant_message(message)
- {
- return Some((id, Some(order), message));
- }
- let order = envelope
- .metadata
- .as_ref()
- .filter(|metadata| !metadata.inherited_user_message)
- .and_then(|metadata| metadata.user_input_order)
- .map(RetainedContextOrder::Local);
- let order = retained.map(|(order, _)| order).or(order);
- let message = if order.is_some() {
- GuardianRootMessage::Assistant(text)
- } else {
- GuardianRootMessage::UnorderedAssistant(text)
- };
- Some((id, order, message))
- })
- .collect::<Vec<_>>();
- let mut assistant_messages = reconciled
- .ordered_entries()
- .filter_map(|(order, entry)| {
+ if latest_user_turn_id.is_none() {
+ latest_user_turn_id = latest_legacy_turn_id;
+ }
+ }
+ let mut missing_assistant_context = retained_context.has_omitted_assistant_messages();
+ // Prefer a renderable retained original over a shortened checkpoint copy.
+ // Otherwise preserve the bounded live evidence, including confirmed messaging sends.
+ let live_assistant_messages = root_history
+ .annotated_items()
+ .iter()
+ .filter(|envelope| {
+ !envelope
+ .metadata
+ .as_ref()
+ .is_some_and(|metadata| metadata.compaction_output)
+ })
+ .filter_map(|envelope| {
+ let text = root_assistant_text(&envelope.item, &delivered_messages)?;
+ let id = envelope
+ .item
+ .id()
+ .map(codex_protocol::ResponseItemId::as_str);
+ let retained = reconciled.ordered_entries().find_map(|(order, entry)| {
let RetainedContextEntry::AssistantMessage(message) = entry else {
return None;
};
- if message.message_id.as_deref().is_some_and(|id| {
- live_assistant_messages
- .iter()
- .any(|(live_id, _, _)| *live_id == Some(id))
- }) {
- return None;
- }
- let rendered = codex_guardian_context::retained_assistant_message(message);
- missing_assistant_context |= rendered.is_none();
- rendered.map(|message| (Some(order), message))
- })
- .collect::<Vec<_>>();
- assistant_messages.extend(
- live_assistant_messages
- .into_iter()
- .map(|(_, order, message)| (order, message)),
- );
- // Keep the nearest known assistant context for each ordinary reply. Verified
- // answers already include their questions; unsequenced sources cannot be paired.
- let reply_context_orders = messages
- .iter()
- .filter_map(|(user_order, message)| {
- let (Some(user_order), GuardianRootMessage::User(_)) = (user_order, message)
- else {
- return None;
- };
- assistant_messages
+ id.filter(|id| message.message_id.as_deref() == Some(*id))
+ .map(|_| (order, message))
+ });
+ if let Some((order, message)) = retained
+ && let Some(message) =
+ codex_guardian_context::retained_assistant_message(message)
+ {
+ return Some((id, Some(order), message));
+ }
+ let order = envelope
+ .metadata
+ .as_ref()
+ .filter(|metadata| !metadata.inherited_user_message)
+ .and_then(|metadata| metadata.user_input_order)
+ .map(RetainedContextOrder::Local);
+ let order = retained.map(|(order, _)| order).or(order);
+ let message = if order.is_some() {
+ GuardianRootMessage::Assistant(text)
+ } else {
+ GuardianRootMessage::UnorderedAssistant(text)
+ };
+ Some((id, order, message))
+ })
+ .collect::<Vec<_>>();
+ let mut assistant_messages = reconciled
+ .ordered_entries()
+ .filter_map(|(order, entry)| {
+ let RetainedContextEntry::AssistantMessage(message) = entry else {
+ return None;
+ };
+ if message.message_id.as_deref().is_some_and(|id| {
+ live_assistant_messages
.iter()
- .filter_map(|(order, _)| *order)
- .filter(|order| order < user_order)
- .max()
- })
- .collect::<Vec<_>>();
- // Stable sorting keeps other live evidence ahead of retained-only extras.
- assistant_messages.sort_by_key(|(order, _)| {
- order.filter(|order| reply_context_orders.contains(order))
- });
- let available =
- MAX_ROOT_MESSAGES.saturating_sub(messages.len() + legacy_messages.len());
- missing_assistant_context |= assistant_messages.len() > available;
- assistant_messages.drain(..assistant_messages.len().saturating_sub(available));
- messages.extend(assistant_messages);
- messages.sort_by_key(|(order, _)| (order.is_none(), *order));
- let mut messages = messages
+ .any(|(live_id, _, _)| *live_id == Some(id))
+ }) {
+ return None;
+ }
+ let rendered = codex_guardian_context::retained_assistant_message(message);
+ missing_assistant_context |= rendered.is_none();
+ rendered.map(|message| (Some(order), message))
+ })
+ .collect::<Vec<_>>();
+ assistant_messages.extend(
+ live_assistant_messages
.into_iter()
- .map(|(_, message)| message)
- .collect::<Vec<_>>();
- if missing_assistant_context {
- messages.insert(
- /*index*/ 0,
- GuardianRootMessage::IncompleteAssistantContext,
- );
- }
- let mut authorization_version = root_evidence.authorization_version(history.as_ref());
- if !authorization_version.retained_context_complete {
- messages.insert(
- /*index*/ 0,
- GuardianRootMessage::IncompleteVerifiedAnswers,
- );
- }
- if missing_root_instructions {
- authorization_version.retained_context_complete = false;
- messages.insert(
- /*index*/ 0,
- GuardianRootMessage::IncompleteRootInstructions,
- );
- }
- messages.insert(/*index*/ 0, GuardianRootMessage::RetainedContextScope);
- if !legacy_messages.is_empty() {
- legacy_messages.push_front(GuardianRootMessage::LegacyContextScope);
- legacy_messages.extend(messages);
- messages = legacy_messages.into_iter().collect();
- }
- (messages, authorization_version)
- } else {
- let mut messages = history
- .review_items()
- .filter_map(|item| match (parse_turn_item(item), item) {
- (Some(TurnItem::UserMessage(message)), _) => {
- let message = message.message();
- (!is_summary_message(&message)
- && !message.trim_start().starts_with("<user_action>"))
- .then(|| {
- latest_user_turn_id = item.turn_id().map(str::to_owned);
- GuardianRootMessage::User(
- guardian_truncate_text(&message, GUARDIAN_MAX_ROOT_MESSAGE_TOKENS)
- .0,
- )
- })
- }
- (_, ResponseItem::FunctionCall { call_id, .. }) => root_evidence
- .user_input_for_call(history.as_ref(), call_id)
- .map(GuardianRootMessage::UserInput),
- (Some(TurnItem::AgentMessage(message)), _)
- if !matches!(message.phase, None | Some(MessagePhase::FinalAnswer)) =>
- {
- None
- }
- _ => root_assistant_text(item, &delivered_messages)
- .map(GuardianRootMessage::Assistant),
- })
- .collect::<Vec<_>>();
- let authorization_version = root_evidence.authorization_version(history.as_ref());
- if !authorization_version.retained_context_complete {
- // Keep the host warning even when the root-message cap evicts older evidence.
- messages.push(GuardianRootMessage::IncompleteVerifiedAnswers);
- }
- messages.drain(..messages.len().saturating_sub(MAX_ROOT_MESSAGES));
- (messages, authorization_version)
- };
+ .map(|(_, order, message)| (order, message)),
+ );
+ // Keep the nearest known assistant context for each ordinary reply. Verified
+ // answers already include their questions; unsequenced sources cannot be paired.
+ let reply_context_orders = messages
+ .iter()
+ .filter_map(|(user_order, message)| {
+ let (Some(user_order), GuardianRootMessage::User(_)) = (user_order, message) else {
+ return None;
+ };
+ assistant_messages
+ .iter()
+ .filter_map(|(order, _)| *order)
+ .filter(|order| order < user_order)
+ .max()
+ })
+ .collect::<Vec<_>>();
+ // Stable sorting keeps other live evidence ahead of retained-only extras.
+ assistant_messages
+ .sort_by_key(|(order, _)| order.filter(|order| reply_context_orders.contains(order)));
+ let available = MAX_ROOT_MESSAGES.saturating_sub(messages.len() + legacy_messages.len());
+ missing_assistant_context |= assistant_messages.len() > available;
+ assistant_messages.drain(..assistant_messages.len().saturating_sub(available));
+ messages.extend(assistant_messages);
+ messages.sort_by_key(|(order, _)| (order.is_none(), *order));
+ let mut messages = messages
+ .into_iter()
+ .map(|(_, message)| message)
+ .collect::<Vec<_>>();
+ if missing_assistant_context {
+ messages.insert(
+ /*index*/ 0,
+ GuardianRootMessage::IncompleteAssistantContext,
+ );
+ }
+ let mut authorization_version = root_evidence.authorization_version(history.as_ref());
+ if !authorization_version.retained_context_complete {
+ messages.insert(
+ /*index*/ 0,
+ GuardianRootMessage::IncompleteVerifiedAnswers,
+ );
+ }
+ if missing_root_instructions {
+ authorization_version.retained_context_complete = false;
+ messages.insert(
+ /*index*/ 0,
+ GuardianRootMessage::IncompleteRootInstructions,
+ );
+ }
+ messages.insert(/*index*/ 0, GuardianRootMessage::RetainedContextScope);
+ if !legacy_messages.is_empty() {
+ legacy_messages.push_front(GuardianRootMessage::LegacyContextScope);
+ legacy_messages.extend(messages);
+ messages = legacy_messages.into_iter().collect();
+ }
let trusted_skill_paths = latest_user_turn_id
.as_deref()
.map(|turn_id| root_evidence.trusted_skill_paths(turn_id))
diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rs
index bedbbac682..f7e10cfb33 100644
--- a/codex-rs/core/src/codex_thread.rs
+++ b/codex-rs/core/src/codex_thread.rs
@@ -166,8 +166,6 @@ pub use codex_guardian_context::GuardianRootMessage;
pub struct GuardianAuthorizationVersion {
/// User-message/reset revision, preserved across compaction and internal context.
pub user_message_revision: u64,
- /// Successful host answers captured by the temporary legacy path.
- pub user_input_response_count: usize,
/// False when required retained answers or root instructions are unavailable.
pub retained_context_complete: bool,
}
diff --git a/codex-rs/core/src/context/guardian_review_evidence.rs b/codex-rs/core/src/context/guardian_review_evidence.rs
index 6067ff72ca..9363b9c589 100644
--- a/codex-rs/core/src/context/guardian_review_evidence.rs
+++ b/codex-rs/core/src/context/guardian_review_evidence.rs
@@ -1,6 +1,5 @@
//! Selects Guardian answer evidence from the review's history snapshot and retains reviews.
//! Retained answers survive restart even while incompatible checkpoints use legacy review.
-//! Sessions without retained capture continue using the bounded runtime buffer.
use std::collections::BTreeSet;
use std::collections::VecDeque;
@@ -11,22 +10,14 @@ use std::sync::PoisonError;
use codex_extension_api::ConversationHistorySnapshot;
use codex_guardian_context::MAX_PREVIOUS_REVIEWS;
use codex_protocol::models::ContentItemKind;
-use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::GuardianAssessmentEvent;
-use codex_protocol::request_user_input::RequestUserInputQuestion;
-use codex_protocol::request_user_input::RequestUserInputResponse;
use serde_json::json;
use super::ContextualUserFragment;
use crate::codex_thread::GuardianAuthorizationVersion;
-use crate::codex_thread::GuardianRootMessage;
-use crate::guardian::guardian_truncate_text;
-const MAX_RETAINED_USER_INPUTS: usize = 8;
const MAX_TRUSTED_SKILLS: usize = 16;
const MAX_TRUSTED_SKILL_PATHS_BYTES: usize = 2_048;
-const MAX_GUARDIAN_USER_INPUT_ANSWERS: usize = 8;
-const MAX_GUARDIAN_USER_INPUT_TOKENS: usize = 900;
/// Selected answer fragments and the authorization state they describe.
pub struct GuardianUserInputSnapshot {
@@ -47,68 +38,11 @@ pub struct GuardianReviewEvidence {
#[derive(Debug, Default)]
struct GuardianReviewEvidenceState {
reviews: VecDeque<Arc<GuardianReviewEvidenceRecord>>,
- user_inputs: VecDeque<(String, String)>,
- user_input_response_count: usize,
trusted_skill_turn_id: Option<String>,
trusted_skill_paths: BTreeSet<String>,
}
impl GuardianReviewEvidence {
- /// Preserves the legacy capture limits before hooks can replace the tool output.
- pub(crate) fn record_user_input(
- &self,
- history: &dyn ConversationHistorySnapshot,
- call_id: &str,
- questions: &[RequestUserInputQuestion],
- response: &RequestUserInputResponse,
- ) {
- if history.retained_context().is_some() {
- return;
- }
- let fragment = questions
- .iter()
- .filter_map(|question| {
- let response = response.answers.get(&question.id)?;
- let answers = response
- .answers
- .iter()
- .filter(|answer| !answer.trim().is_empty())
- .take(MAX_GUARDIAN_USER_INPUT_ANSWERS)
- .cloned()
- .collect::<Vec<_>>();
- if answers.is_empty() {
- return None;
- }
- let mut question_text = question.question.clone();
- for option in question
- .options
- .iter()
- .flatten()
- .filter(|option| response.answers.contains(&option.label))
- .take(MAX_GUARDIAN_USER_INPUT_ANSWERS)
- {
- question_text.push_str(&format!("\n{}: {}", option.label, option.description));
- }
- Some(format!(
- "{}{}",
- GuardianRootMessage::Assistant(question_text).render(),
- GuardianRootMessage::User(answers.join("\n")).render()
- ))
- })
- .take(MAX_GUARDIAN_USER_INPUT_ANSWERS)
- .collect::<String>();
- if fragment.is_empty() {
- return;
- }
- let fragment = guardian_truncate_text(&fragment, MAX_GUARDIAN_USER_INPUT_TOKENS).0;
- let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
- state.user_input_response_count = state.user_input_response_count.saturating_add(1);
- state.user_inputs.push_back((call_id.to_owned(), fragment));
- while state.user_inputs.len() > MAX_RETAINED_USER_INPUTS {
- state.user_inputs.pop_front();
- }
- }
-
/// Reads the selected answer path against the caller's action-time history snapshot.
pub fn user_input_snapshot(
&self,
@@ -119,7 +53,6 @@ impl GuardianReviewEvidence {
let answers = codex_guardian_context::render_verified_answers(context);
let authorization_version = GuardianAuthorizationVersion {
user_message_revision: history.user_message_revision(),
- user_input_response_count: 0,
retained_context_complete: answers.complete,
};
GuardianUserInputSnapshot {
@@ -127,27 +60,13 @@ impl GuardianReviewEvidence {
authorization_version,
}
}
- None => {
- let state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
- let fragments = state
- .user_inputs
- .iter()
- .filter(|(call_id, _)| {
- history.items().chain(history.review_items()).any(|item| {
- matches!(item, ResponseItem::FunctionCall { call_id: id, .. } if id == call_id)
- })
- })
- .map(|(_, fragment)| fragment.clone())
- .collect();
- GuardianUserInputSnapshot {
- fragments,
- authorization_version: GuardianAuthorizationVersion {
- user_message_revision: history.user_message_revision(),
- user_input_response_count: state.user_input_response_count,
- retained_context_complete: true,
- },
- }
- }
+ None => GuardianUserInputSnapshot {
+ fragments: Vec::new(),
+ authorization_version: GuardianAuthorizationVersion {
+ user_message_revision: history.user_message_revision(),
+ retained_context_complete: true,
+ },
+ },
}
}
@@ -158,26 +77,6 @@ impl GuardianReviewEvidence {
self.user_input_snapshot(history).authorization_version
}
- pub(crate) fn user_input_for_call(
- &self,
- history: &dyn ConversationHistorySnapshot,
- call_id: &str,
- ) -> Option<String> {
- match history.retained_context() {
- Some(context) => context
- .verified_answers()
- .find(|answer| answer.call_id == call_id)
- .and_then(codex_guardian_context::render_verified_answer),
- None => self
- .state
- .lock()
- .unwrap_or_else(PoisonError::into_inner)
- .user_inputs
- .iter()
- .find_map(|(id, fragment)| (id == call_id).then(|| fragment.clone())),
- }
- }
-
/// Records a bounded, verified user-owned skill path for one host-owned turn.
pub fn record_trusted_skill(&self, turn_id: &str, path: String) {
if turn_id.is_empty() {
diff --git a/codex-rs/core/src/tools/handlers/request_user_input.rs b/codex-rs/core/src/tools/handlers/request_user_input.rs
index b6f4356980..0f4e7d501f 100644
--- a/codex-rs/core/src/tools/handlers/request_user_input.rs
+++ b/codex-rs/core/src/tools/handlers/request_user_input.rs
@@ -1,5 +1,4 @@
use crate::context::GuardianContextMode;
-use crate::context::GuardianReviewEvidence;
use crate::function_tool::FunctionCallError;
use crate::tools::context::FunctionToolOutput;
use crate::tools::context::ToolInvocation;
@@ -102,14 +101,6 @@ impl RequestUserInputHandler {
"failed to serialize {REQUEST_USER_INPUT_TOOL_NAME} response: {err}"
))
})?;
- if turn.config.features.enabled(Feature::GuardianApproval) {
- let history = session.conversation_history_snapshot().await;
- session
- .services
- .thread_extension_data
- .get_or_init(GuardianReviewEvidence::default)
- .record_user_input(history.as_ref(), &call_id, &questions, &response);
- }
// Capture follows the session flag even while an older checkpoint uses legacy review.
if turn.config.features.enabled(Feature::GuardianApproval)
&& session.guardian_context_mode == GuardianContextMode::ThreadOwned
diff --git a/codex-rs/core/src/tools/handlers/request_user_input_tests.rs b/codex-rs/core/src/tools/handlers/request_user_input_tests.rs
index dc368eb8b2..1c1dbfca16 100644
--- a/codex-rs/core/src/tools/handlers/request_user_input_tests.rs
+++ b/codex-rs/core/src/tools/handlers/request_user_input_tests.rs
@@ -1,8 +1,8 @@
use super::*;
use crate::GuardianAuthorizationVersion;
+use crate::context::GuardianReviewEvidence;
use crate::session::step_context::StepContext;
use crate::session::tests::make_session_and_context;
-use crate::session::tests::make_session_and_context_with_auth_and_config_and_rx;
use crate::session::tests::make_session_and_context_with_rx;
use crate::session::tests::update_selected_settings_for_test;
use crate::session::tests::update_turn_settings_for_test;
@@ -102,160 +102,120 @@ async fn request_user_input_sets_non_blocking_outside_plan_mode(
answer: Option<(&str, String)>,
expected: RenderedVerifiedAnswers,
) {
- for thread_context_enabled in [false, true] {
- let (session, turn, events) = make_session_and_context_with_auth_and_config_and_rx(
- codex_login::CodexAuth::from_api_key("Test API Key"),
- Vec::new(),
- |config| {
- config
- .features
- .set_enabled(Feature::GuardianThreadContext, thread_context_enabled)
- .expect("test context mode");
- },
- )
- .await;
- session
- .services
- .thread_extension_data
- .insert(GuardianReviewEvidence::default());
- let original_history = session.conversation_history_snapshot().await;
- *session.active_turn.lock().await = Some(ActiveTurn::default());
+ let (session, turn, events) = make_session_and_context_with_rx().await;
+ session
+ .services
+ .thread_extension_data
+ .insert(GuardianReviewEvidence::default());
+ let original_history = session.conversation_history_snapshot().await;
+ *session.active_turn.lock().await = Some(ActiveTurn::default());
- let request = tokio::spawn({
- let session = Arc::clone(&session);
- let turn = Arc::clone(&turn);
- async move {
- RequestUserInputHandler {
- available_modes: vec![ModeKind::Default],
- }
- .handle(ToolInvocation {
- session,
- step_context: StepContext::for_test(Arc::clone(&turn)),
- turn,
- cancellation_token: tokio_util::sync::CancellationToken::new(),
- tracker: Arc::new(Mutex::new(TurnDiffTracker::default())),
- call_id: "call-1".to_string(),
- tool_name: codex_tools::ToolName::plain(REQUEST_USER_INPUT_TOOL_NAME),
- source: crate::tools::context::ToolCallSource::Direct,
- payload: ToolPayload::Function {
- arguments: json!({
- "questions": [{
- "header": "Hdr",
- "question": "Pick one",
- "id": "pick_one",
- "options": [
- {
- "label": "A",
- "description": "A"
- },
- {
- "label": "B",
- "description": "B"
- }
- ]
- }]
- })
- .to_string(),
- },
- })
- .await
+ let request = tokio::spawn({
+ let session = Arc::clone(&session);
+ let turn = Arc::clone(&turn);
+ async move {
+ RequestUserInputHandler {
+ available_modes: vec![ModeKind::Default],
}
- });
-
- let event = events.recv().await.expect("request_user_input event");
- let EventMsg::RequestUserInput(request_event) = event.msg else {
- panic!("expected request_user_input event");
- };
- assert_eq!(request_event.call_id, "call-1");
- assert!(!request_event.is_blocking);
-
- session
- .notify_user_input_response(
- &request_event.turn_id,
- RequestUserInputResponse {
- answers: answer
- .iter()
- .map(|(question_id, answer)| {
- (
- (*question_id).to_owned(),
- RequestUserInputAnswer {
- answers: vec![answer.clone()],
+ .handle(ToolInvocation {
+ session,
+ step_context: StepContext::for_test(Arc::clone(&turn)),
+ turn,
+ cancellation_token: tokio_util::sync::CancellationToken::new(),
+ tracker: Arc::new(Mutex::new(TurnDiffTracker::default())),
+ call_id: "call-1".to_string(),
+ tool_name: codex_tools::ToolName::plain(REQUEST_USER_INPUT_TOOL_NAME),
+ source: crate::tools::context::ToolCallSource::Direct,
+ payload: ToolPayload::Function {
+ arguments: json!({
+ "questions": [{
+ "header": "Hdr",
+ "question": "Pick one",
+ "id": "pick_one",
+ "options": [
+ {
+ "label": "A",
+ "description": "A"
},
- )
- })
- .collect(),
+ {
+ "label": "B",
+ "description": "B"
+ }
+ ]
+ }]
+ })
+ .to_string(),
},
- )
- .await;
-
- let output = request
+ })
.await
- .expect("request_user_input handler task should finish")
- .expect("request_user_input handler should succeed");
- assert!(output.success_for_logging());
- let history = session.conversation_history_snapshot().await;
- if thread_context_enabled {
- let RenderedVerifiedAnswers {
- fragments,
- complete,
- } = codex_guardian_context::render_verified_answers(
- history.retained_context().expect("host context snapshot"),
- );
- let expected_fragments = expected
- .fragments
- .iter()
- .map(|fragment| {
- if expected.complete {
- format!("Retained source order: 0\n{fragment}")
- } else {
- fragment.clone()
- }
- })
- .collect::<Vec<_>>();
- assert_eq!(
- (&fragments, complete),
- (&expected_fragments, expected.complete)
- );
- } else {
- assert_eq!(
- history.retained_context(),
- original_history.retained_context()
- );
}
- let evidence = session
- .services
- .thread_extension_data
- .get_or_init(GuardianReviewEvidence::default);
- let legacy_answer = evidence.user_input_for_call(history.as_ref(), "call-1");
- let has_answer = matches!(&answer, Some(("pick_one", answer)) if !answer.trim().is_empty());
- assert_eq!(
- evidence.authorization_version(history.as_ref()),
- GuardianAuthorizationVersion {
- user_message_revision: original_history.user_message_revision()
- + u64::from(thread_context_enabled && has_answer),
- user_input_response_count: usize::from(!thread_context_enabled && has_answer),
- retained_context_complete: !thread_context_enabled || expected.complete,
+ });
+
+ let event = events.recv().await.expect("request_user_input event");
+ let EventMsg::RequestUserInput(request_event) = event.msg else {
+ panic!("expected request_user_input event");
+ };
+ assert_eq!(request_event.call_id, "call-1");
+ assert!(!request_event.is_blocking);
+
+ session
+ .notify_user_input_response(
+ &request_event.turn_id,
+ RequestUserInputResponse {
+ answers: answer
+ .iter()
+ .map(|(question_id, answer)| {
+ (
+ (*question_id).to_owned(),
+ RequestUserInputAnswer {
+ answers: vec![answer.clone()],
+ },
+ )
+ })
+ .collect(),
},
- );
- match &answer {
- Some(("pick_one", answer)) if !thread_context_enabled && !answer.trim().is_empty() => {
- let fragment = legacy_answer.expect("legacy answer");
- assert!(codex_utils_output_truncation::approx_token_count(&fragment) <= 900);
- assert_eq!(
- fragment.contains("<truncated omitted_approx_tokens="),
- !expected.complete,
- );
+ )
+ .await;
+
+ let output = request
+ .await
+ .expect("request_user_input handler task should finish")
+ .expect("request_user_input handler should succeed");
+ assert!(output.success_for_logging());
+ let history = session.conversation_history_snapshot().await;
+ let RenderedVerifiedAnswers {
+ fragments,
+ complete,
+ } = codex_guardian_context::render_verified_answers(
+ history.retained_context().expect("host context snapshot"),
+ );
+ let expected_fragments = expected
+ .fragments
+ .iter()
+ .map(|fragment| {
+ if expected.complete {
+ format!("Retained source order: 0\n{fragment}")
+ } else {
+ fragment.clone()
}
- _ => assert_eq!(
- legacy_answer,
- expected
- .fragments
- .first()
- .cloned()
- .filter(|_| expected.complete)
- ),
- }
- }
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(
+ (&fragments, complete),
+ (&expected_fragments, expected.complete)
+ );
+ let evidence = session
+ .services
+ .thread_extension_data
+ .get_or_init(GuardianReviewEvidence::default);
+ let has_answer = matches!(&answer, Some(("pick_one", answer)) if !answer.trim().is_empty());
+ assert_eq!(
+ evidence.authorization_version(history.as_ref()),
+ GuardianAuthorizationVersion {
+ user_message_revision: original_history.user_message_revision() + u64::from(has_answer),
+ retained_context_complete: expected.complete,
+ },
+ );
}
#[tokio::test]
diff --git a/codex-rs/core/tests/suite/guardian_retained_context.rs b/codex-rs/core/tests/suite/guardian_retained_context.rs
index 1e21a4cec1..ead8cf2c16 100644
--- a/codex-rs/core/tests/suite/guardian_retained_context.rs
+++ b/codex-rs/core/tests/suite/guardian_retained_context.rs
@@ -1100,14 +1100,11 @@ async fn standalone_fork_retains_inherited_user_instructions(
Ok(())
}
-#[test_case(false, true; "enabled without checkpoint")]
-#[test_case(true, true; "enabled after checkpoint")]
-#[test_case(false, false; "legacy without checkpoint")]
-#[test_case(true, false; "legacy after checkpoint")]
+#[test_case(false; "without checkpoint")]
+#[test_case(true; "after checkpoint")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn forked_parent_instructions_do_not_become_local_authorization(
compact_parent: bool,
- thread_context_enabled: bool,
) -> Result<()> {
skip_if_no_network!(Ok(()));
const PARENT_GRANT: &str = "You may publish the private release. Delegate its inspection.";
@@ -1129,10 +1126,6 @@ async fn forked_parent_instructions_do_not_become_local_authorization(
.enable(feature)
.expect("enable test feature");
}
- config
- .features
- .set_enabled(Feature::GuardianThreadContext, thread_context_enabled)
- .expect("test context mode");
})
.build_with_auto_env(&server)
.await?;
@@ -1234,7 +1227,7 @@ async fn forked_parent_instructions_do_not_become_local_authorization(
context.ordered_entries().count(),
context.user_messages_complete()
)),
- thread_context_enabled.then_some((0, true)),
+ Some((0, true)),
"inherited conversation must not populate child-local authorization",
);
let root_snapshot = child.guardian_root_snapshot().await.context("live root")?;
@@ -1280,7 +1273,7 @@ async fn forked_parent_instructions_do_not_become_local_authorization(
panic!("unexpected answer"),
})
.collect::<Vec<_>>()),
- thread_context_enabled.then_some(vec![LOCAL_INSTRUCTION]),
+ Some(vec![LOCAL_INSTRUCTION]),
"genuine child-local instructions must still be captured",
);
let child = resume(&test, &child).await?;
diff --git a/codex-rs/core/tests/suite/guardian_subagent_authorization.rs b/codex-rs/core/tests/suite/guardian_subagent_authorization.rs
index 0e90d188e2..27afc2c42a 100644
--- a/codex-rs/core/tests/suite/guardian_subagent_authorization.rs
+++ b/codex-rs/core/tests/suite/guardian_subagent_authorization.rs
@@ -87,13 +87,13 @@ enum MessagingOutcome {
#[derive(Clone, Copy)]
enum MessagingTool {
Plural,
+ PluralConnector,
SingularConnector,
SingularFlat,
}
#[derive(Clone, Copy)]
enum RootContext {
- Legacy,
Retained,
Migrating,
RetainedAtMessageLimit,
@@ -160,8 +160,6 @@ async fn mount_completion(
.await
}
-#[test_case(RootAnswer::Complete, RootContext::Legacy, MessagingOutcome::Complete, MessagingTool::Plural; "legacy_complete_answer")]
-#[test_case(RootAnswer::Oversized, RootContext::Legacy, MessagingOutcome::Complete, MessagingTool::Plural; "legacy_oversized_answer")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::Complete, MessagingTool::Plural; "retained_complete_answer")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::Block, MessagingTool::Plural; "retained_blocked_post_hook")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::CancelPostHook, MessagingTool::Plural; "retained_cancelled_post_hook")]
@@ -170,11 +168,11 @@ async fn mount_completion(
#[test_case(RootAnswer::Complete, RootContext::Migrating, MessagingOutcome::Complete, MessagingTool::Plural; "migrating_complete_answer")]
#[test_case(RootAnswer::Oversized, RootContext::Migrating, MessagingOutcome::Complete, MessagingTool::Plural; "migrating_oversized_answer")]
#[test_case(RootAnswer::Complete, RootContext::RetainedAtMessageLimit, MessagingOutcome::Complete, MessagingTool::Plural; "bounded_retained_root_messages")]
-#[test_case(RootAnswer::Complete, RootContext::Legacy, MessagingOutcome::Complete, MessagingTool::SingularConnector; "legacy_user_message_connector")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::Complete, MessagingTool::SingularConnector; "retained_user_message_connector")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::Complete, MessagingTool::SingularFlat; "retained_user_message_flat")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::Block, MessagingTool::SingularConnector; "retained_user_message_connector_blocked_post_hook")]
#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::CancelBeforeConfirmation, MessagingTool::SingularFlat; "retained_user_message_flat_cancelled_before_confirmation")]
+#[test_case(RootAnswer::Complete, RootContext::Retained, MessagingOutcome::Complete, MessagingTool::PluralConnector; "retained_user_messaging_connector")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn guardian_subagent_review_preserves_late_root_user_authorization(
root_answer: RootAnswer,
@@ -188,7 +186,6 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
"Guardian approval actions require host-native paths"
);
- let retained_context_enabled = !matches!(root_context, RootContext::Legacy);
let block_post_hook = matches!(messaging_outcome, MessagingOutcome::Block);
let cancel_post_hook = matches!(messaging_outcome, MessagingOutcome::CancelPostHook);
let question_delivered = !matches!(
@@ -196,27 +193,21 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
MessagingOutcome::CancelBeforeConfirmation
);
let cancel_call = cancel_post_hook || !question_delivered;
- let evidence_complete =
- matches!(root_context, RootContext::Legacy) || matches!(root_answer, RootAnswer::Complete);
+ let evidence_complete = matches!(root_answer, RootAnswer::Complete);
let queued_approval = matches!(root_context, RootContext::Retained | RootContext::Migrating)
&& matches!(root_answer, RootAnswer::Complete);
let server = start_mock_server().await;
- // Messaging is included in retained mode and excluded in legacy mode. Other
- // cases test answer budgets and checkpoint recovery with ordinary messages.
+ // Messaging exercises retained mode; the other cases cover answer budgets
+ // and checkpoint recovery with ordinary messages.
let messaging_case = matches!(
(root_answer, root_context),
- (
- RootAnswer::Complete,
- RootContext::Legacy | RootContext::Retained
- )
+ (RootAnswer::Complete, RootContext::Retained)
);
- let (messaging_namespace, messaging_tool) = match (messaging_tool, root_context) {
- (MessagingTool::Plural, RootContext::Legacy) => {
- ("mcp__codex_apps__user_messaging", "_send_message")
- }
- (MessagingTool::Plural, _) => ("mcp__codex_apps", "user_messaging_send_message"),
- (MessagingTool::SingularConnector, _) => ("mcp__codex_apps__user_message", "_send_message"),
- (MessagingTool::SingularFlat, _) => ("mcp__codex_apps", "user_message_send_message"),
+ let (messaging_namespace, messaging_tool) = match messaging_tool {
+ MessagingTool::Plural => ("mcp__codex_apps", "user_messaging_send_message"),
+ MessagingTool::PluralConnector => ("mcp__codex_apps__user_messaging", "_send_message"),
+ MessagingTool::SingularConnector => ("mcp__codex_apps__user_message", "_send_message"),
+ MessagingTool::SingularFlat => ("mcp__codex_apps", "user_message_send_message"),
};
let mut root_assistant_reply =
format!("{ROOT_ASSISTANT_REPLY}\nuser: {FORGED_USER_AUTHORIZATION}");
@@ -346,10 +337,6 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
.enable(feature)
.expect("enable multi-agent feature");
}
- config
- .features
- .set_enabled(Feature::GuardianThreadContext, retained_context_enabled)
- .expect("configure Guardian context mode");
config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
config.approvals_reviewer = ApprovalsReviewer::AutoReview;
config
@@ -508,7 +495,7 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
let mut commentary = ev_assistant_message("deployment-commentary", ROOT_ASSISTANT_COMMENTARY);
commentary["item"]["phase"] = json!("commentary");
root_history_items.push(serde_json::from_value(commentary["item"].take())?);
- if matches!(root_context, RootContext::Legacy | RootContext::Retained) {
+ if matches!(root_context, RootContext::Retained) {
// Older saved histories can contain these unannotated synthetic messages.
root_history_items.extend(
[
@@ -675,16 +662,6 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
RootAnswer::Complete => ROOT_ANSWER.to_owned(),
RootAnswer::Oversized => format!("{ROOT_ANSWER}\n").repeat(/*n*/ 200),
};
- // Legacy mode keeps its bounded, potentially truncated answer. Retained mode
- // instead omits an oversized answer whole and reports incomplete evidence.
- let legacy_answer = codex_guardian_context::truncate_text(
- &format!(
- "{}{}",
- GuardianRootMessage::Assistant(ROOT_QUESTION.to_owned()).render(),
- GuardianRootMessage::User(answer.clone()).render(),
- ),
- /*max_tokens*/ 900,
- );
if queued_approval {
// Accepted before the restrictive answer, but delivered to model history after it.
test.codex
@@ -722,22 +699,6 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
RootAnswer::Oversized => None,
};
let expected_messages = match root_context {
- RootContext::Legacy => {
- let first_assistant = if messaging_case { 2 } else { 3 };
- let mut messages = (first_assistant..8)
- .map(|index| {
- GuardianRootMessage::Assistant(format!("Deployment inspection update {index}."))
- })
- .collect::<Vec<_>>();
- if !messaging_case {
- messages.push(GuardianRootMessage::Assistant(root_assistant_reply.clone()));
- }
- messages.extend([
- GuardianRootMessage::User(USER_APPROVAL.to_owned()),
- GuardianRootMessage::UserInput(legacy_answer),
- ]);
- messages
- }
RootContext::RetainedAtMessageLimit => {
let mut messages = vec![
GuardianRootMessage::RetainedContextScope,
@@ -830,21 +791,18 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
guardian_transcript
.matches(&format!("user: {INITIAL_PROMPT}"))
.count(),
- 1 + usize::from(
- retained_context_enabled
- && !matches!(root_context, RootContext::RetainedAtMessageLimit)
- ),
+ 1 + usize::from(!matches!(root_context, RootContext::RetainedAtMessageLimit)),
"the worker transcript keeps the original instructions; the root projection selects bounded retained evidence"
);
assert_eq!(
guardian_transcript.contains("some verified user answers are unavailable"),
- retained_context_enabled && !evidence_complete,
+ !evidence_complete,
);
for text in [ROOT_QUESTION, ROOT_ANSWER] {
assert_eq!(
guardian_transcript.contains(text),
- !retained_context_enabled || matches!(root_answer, RootAnswer::Complete),
- "retained mode omits oversized answers whole; legacy mode keeps its truncated answer"
+ matches!(root_answer, RootAnswer::Complete),
+ "oversized retained answers are omitted whole"
);
}
assert!(guardian_transcript.contains(&format!("user: {USER_APPROVAL}")));
@@ -854,14 +812,12 @@ async fn guardian_subagent_review_preserves_late_root_user_authorization(
] {
assert_eq!(
guardian_transcript.contains(&format!("assistant: {text}")),
- !matches!(root_context, RootContext::RetainedAtMessageLimit)
- && (!messaging_case || retained_context_enabled)
- && question_delivered,
+ !matches!(root_context, RootContext::RetainedAtMessageLimit) && question_delivered,
);
}
assert_eq!(
guardian_transcript.contains(ROOT_ASSISTANT_COMMENTARY),
- retained_context_enabled && !matches!(root_context, RootContext::RetainedAtMessageLimit),
+ !matches!(root_context, RootContext::RetainedAtMessageLimit),
);
assert!(!guardian_transcript.contains(ORIGINAL_QUESTION));
assert!(!guardian_transcript.contains(SYNTHETIC_AUTHORIZATION));