Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Use compact display metadata for Guardian review threads (#47302)

Charlie Marsh4f6c106cddb6
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs
index 48fc7b52fb..fd7c1ebc86 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_sync_session_tests.rs
@@ -13,6 +13,8 @@ use codex_app_server_protocol::ThreadClosedNotification;
use codex_app_server_protocol::ThreadListResponse;
use codex_app_server_protocol::ThreadReadParams;
use codex_app_server_protocol::ThreadReadResponse;
+use codex_app_server_protocol::ThreadSetNameParams;
+use codex_app_server_protocol::ThreadSetNameResponse;
use codex_app_server_protocol::ThreadSourceKind;
use codex_app_server_protocol::ThreadUnsubscribeParams;
use codex_app_server_protocol::ThreadUnsubscribeResponse;
@@ -330,14 +332,49 @@ async fn managed_reviewers_reuse_fork_and_resume_after_parent_shutdown(
let closed: ThreadClosedNotification =
timeout(TIMEOUT, app.read_notification("thread/closed")).await??;
assert_eq!(closed.thread_id, parent.id);
+ let state_db = StateRuntime::init(
+ codex_state::SqliteConfig::new_for_testing(codex_home.path().abs()),
+ "mock_provider".into(),
+ )
+ .await?;
+ let metadata = state_db
+ .get_thread(codex_protocol::ThreadId::from_string(&reviewer_id)?)
+ .await?
+ .expect("reviewer metadata should be persisted");
+ assert_eq!(
+ (
+ metadata.title.as_str(),
+ metadata.name.as_deref(),
+ metadata.preview.as_deref(),
+ metadata.first_user_message.as_deref(),
+ ),
+ ("Guardian review", None, Some("Approval review"), None),
+ );
// Saved reviewers remain discoverable through the existing subagent filters.
for kind in [ThreadSourceKind::SubAgent, ThreadSourceKind::SubAgentOther] {
let params = serde_json::from_value(json!({"sourceKinds": [kind]}))?;
let listed: ThreadListResponse = app
.request(|request_id| ClientRequest::ThreadList { request_id, params })
.await?;
- assert!(listed.data.iter().any(|thread| thread.id == reviewer_id));
+ let reviewer = listed
+ .data
+ .iter()
+ .find(|thread| thread.id == reviewer_id)
+ .expect("reviewer should be listed");
+ assert_eq!(
+ (reviewer.name.as_deref(), reviewer.preview.as_str()),
+ (Some("Guardian review"), "Approval review"),
+ );
}
+ let _: ThreadSetNameResponse = app
+ .request(|request_id| ClientRequest::ThreadSetName {
+ request_id,
+ params: ThreadSetNameParams {
+ thread_id: reviewer_id.clone(),
+ name: "Named Guardian review".to_string(),
+ },
+ })
+ .await?;
let resumed: ThreadResumeResponse = app
.request(|request_id| ClientRequest::ThreadResume {
request_id,
@@ -349,6 +386,11 @@ async fn managed_reviewers_reuse_fork_and_resume_after_parent_shutdown(
.await?;
assert_eq!(resumed.thread.id, reviewer_id);
assert_eq!(resumed.thread.source, read.thread.source);
+ assert_eq!(
+ resumed.thread.name.as_deref(),
+ Some("Named Guardian review")
+ );
+ assert_eq!(resumed.thread.preview, "Approval review");
let completed = timeout(
TIMEOUT,
app.start_turn_and_wait_for_completion(TurnStartParams {
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
index f8feea4a33..d8926e825a 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
@@ -1768,6 +1768,38 @@ async fn guardian_v2_routes_scoped_tool_approvals(
})
.await?;
timeout(TIMEOUT, app_server.shutdown_gracefully()).await??;
+ let reviewer_id = responses_state
+ .guardian_requests
+ .lock()
+ .expect("Guardian requests")[0]["client_metadata"]["thread_id"]
+ .as_str()
+ .expect("reviewer ID")
+ .to_owned();
+ let state_db = StateRuntime::init(
+ codex_state::SqliteConfig::new_for_testing(codex_home.path().abs()),
+ "mock_provider".to_owned(),
+ )
+ .await?;
+ let metadata = state_db
+ .get_thread(codex_protocol::ThreadId::from_string(&reviewer_id)?)
+ .await?
+ .expect("reviewer metadata should be persisted");
+ assert_eq!(
+ (
+ metadata.source.as_str(),
+ metadata.title.as_str(),
+ metadata.name.as_deref(),
+ metadata.preview.as_deref(),
+ metadata.first_user_message.as_deref(),
+ ),
+ (
+ r#"{"subagent":{"other":"guardian"}}"#,
+ "Guardian review",
+ None,
+ Some("Approval review"),
+ None
+ ),
+ );
let events = captured_analytics_events(&analytics_server).await;
let turn = &turn["event_params"];
assert_eq!(turn["guardian_v2_enabled"], classifier_in_scope);
diff --git a/codex-rs/rollout/src/list.rs b/codex-rs/rollout/src/list.rs
index 534d25abfb..219b243153 100644
--- a/codex-rs/rollout/src/list.rs
+++ b/codex-rs/rollout/src/list.rs
@@ -1180,6 +1180,12 @@ async fn read_head_summary(path: &Path, head_limit: usize) -> io::Result<HeadTai
summary.cli_version = Some(session_meta_line.meta.cli_version);
summary.created_at = Some(session_meta_line.meta.timestamp.clone());
summary.saw_session_meta = true;
+
+ if codex_state::is_guardian_review_source(&session_meta_line.meta.source) {
+ // The synthetic prompt is not needed for the thread summary.
+ summary.preview = Some(codex_state::GUARDIAN_THREAD_PREVIEW.to_string());
+ break;
+ }
}
}
RolloutItem::ResponseItem(_) | RolloutItem::InterAgentCommunication(_) => {
diff --git a/codex-rs/rollout/src/tests.rs b/codex-rs/rollout/src/tests.rs
index dc25b4e856..27fd11ba4d 100644
--- a/codex-rs/rollout/src/tests.rs
+++ b/codex-rs/rollout/src/tests.rs
@@ -41,6 +41,7 @@ use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
+use codex_protocol::protocol::SubAgentSource;
use codex_protocol::protocol::ThreadGoal;
use codex_protocol::protocol::ThreadGoalStatus;
use codex_protocol::protocol::ThreadGoalUpdatedEvent;
@@ -1190,6 +1191,36 @@ async fn test_list_threads_uses_goal_objective_as_preview() {
assert_eq!(item.first_user_message, None);
}
+#[tokio::test]
+async fn test_guardian_rollout_uses_compact_preview() {
+ let temp = TempDir::new().unwrap();
+ let home = temp.path();
+
+ let uuid = Uuid::from_u128(/*v*/ 102);
+ let ts = "2025-05-03T10-30-00";
+ write_session_file(
+ home,
+ ts,
+ uuid,
+ /*num_records*/ 1,
+ Some(SessionSource::SubAgent(SubAgentSource::Other(
+ "guardian".to_string(),
+ ))),
+ )
+ .unwrap();
+
+ let path = home.join(format!("sessions/2025/05/03/rollout-{ts}-{uuid}.jsonl"));
+ let item = crate::read_thread_item_from_rollout(path)
+ .await
+ .expect("guardian rollout should produce a thread item");
+
+ assert_eq!(
+ item.preview.as_deref(),
+ Some(codex_state::GUARDIAN_THREAD_PREVIEW)
+ );
+ assert_eq!(item.first_user_message, None);
+}
+
#[tokio::test]
async fn test_goal_first_thread_reads_later_user_message() {
let temp = TempDir::new().unwrap();
diff --git a/codex-rs/state/src/extract.rs b/codex-rs/state/src/extract.rs
index 2bf5470d7f..b761940061 100644
--- a/codex-rs/state/src/extract.rs
+++ b/codex-rs/state/src/extract.rs
@@ -4,6 +4,8 @@ use codex_protocol::items::TurnItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::SessionMetaLine;
+use codex_protocol::protocol::SessionSource;
+use codex_protocol::protocol::SubAgentSource;
use codex_protocol::protocol::TurnContextItem;
use codex_protocol::protocol::UserMessageEvent;
use codex_protocol::protocol::strip_user_message_prefix;
@@ -11,6 +13,17 @@ use codex_protocol::protocol::user_message_preview;
use serde::Serialize;
use serde_json::Value;
+pub const GUARDIAN_THREAD_TITLE: &str = "Guardian review";
+pub const GUARDIAN_THREAD_PREVIEW: &str = "Approval review";
+
+/// Identifies internal review threads whose user messages are synthetic approval prompts.
+pub fn is_guardian_review_source(source: &SessionSource) -> bool {
+ matches!(
+ source,
+ SessionSource::SubAgent(SubAgentSource::Other(name)) if name == "guardian"
+ )
+}
+
/// Apply a rollout item to the metadata structure.
pub fn apply_rollout_item(
metadata: &mut ThreadMetadata,
@@ -121,15 +134,17 @@ fn apply_event_msg(metadata: &mut ThreadMetadata, event: &EventMsg) {
metadata.tokens_used = info.total_token_usage.total_tokens.max(0);
}
}
- EventMsg::UserMessage(user) => {
+ EventMsg::UserMessage(user) if !metadata_is_guardian_review(metadata) => {
apply_user_message(metadata, user);
}
EventMsg::ItemCompleted(event) => {
- if let TurnItem::UserMessage(user) = &event.item {
+ if let TurnItem::UserMessage(user) = &event.item
+ && !metadata_is_guardian_review(metadata)
+ {
apply_user_message(metadata, &user.as_legacy_user_message_event());
}
}
- EventMsg::ThreadGoalUpdated(event) => {
+ EventMsg::ThreadGoalUpdated(event) if !metadata_is_guardian_review(metadata) => {
let objective = event.goal.objective.trim();
if !objective.is_empty() {
set_preview_if_empty(metadata, Some(objective.to_string()));
@@ -151,6 +166,12 @@ fn apply_event_msg(metadata: &mut ThreadMetadata, event: &EventMsg) {
fn apply_response_item(_metadata: &mut ThreadMetadata, _item: &ResponseItem) {}
+pub(crate) fn metadata_is_guardian_review(metadata: &ThreadMetadata) -> bool {
+ serde_json::from_str::<SessionSource>(metadata.source.as_str())
+ .as_ref()
+ .is_ok_and(is_guardian_review_source)
+}
+
fn apply_user_message(metadata: &mut ThreadMetadata, user: &UserMessageEvent) {
let preview = user_message_preview(user);
if metadata.first_user_message.is_none() {
@@ -183,6 +204,7 @@ pub(crate) fn enum_to_string<T: Serialize>(value: &T) -> String {
mod tests {
use super::apply_rollout_item;
use super::rollout_item_affects_thread_metadata;
+ use crate::ThreadMetadataBuilder;
use crate::model::ThreadMetadata;
use chrono::DateTime;
use chrono::Utc;
@@ -206,6 +228,7 @@ mod tests {
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
+ use codex_protocol::protocol::SubAgentSource;
use codex_protocol::protocol::ThreadGoal;
use codex_protocol::protocol::ThreadGoalStatus;
use codex_protocol::protocol::ThreadGoalUpdatedEvent;
@@ -290,6 +313,62 @@ mod tests {
assert_eq!(metadata.title, "actual user request");
}
+ #[test]
+ fn guardian_projection_skips_prompts_and_preserves_custom_names() {
+ let thread_id = ThreadId::new();
+ let source = SessionSource::SubAgent(SubAgentSource::Other("guardian".to_string()));
+ let mut metadata =
+ ThreadMetadataBuilder::new(thread_id, PathBuf::new(), Utc::now(), source.clone())
+ .build("test-provider");
+ let session_meta = RolloutItem::SessionMeta(SessionMetaLine {
+ meta: SessionMeta {
+ session_id: thread_id.into(),
+ id: thread_id,
+ source,
+ ..Default::default()
+ },
+ git: None,
+ });
+ apply_rollout_item(&mut metadata, &session_meta, "test-provider");
+ let mut expected = metadata.clone();
+ expected.title = super::GUARDIAN_THREAD_TITLE.to_string();
+ expected.name = None;
+ expected.preview = Some(super::GUARDIAN_THREAD_PREVIEW.to_string());
+ expected.first_user_message = None;
+
+ let user = UserMessageItem::new(&[UserInput::Text {
+ text: "large synthetic guardian prompt".to_string(),
+ text_elements: Vec::new(),
+ }]);
+ for event in [
+ EventMsg::UserMessage(user.as_legacy_user_message_event()),
+ EventMsg::ItemCompleted(ItemCompletedEvent {
+ thread_id,
+ turn_id: "turn-1".to_string(),
+ item: TurnItem::UserMessage(user),
+ started_at_ms: Some(0),
+ completed_at_ms: 0,
+ }),
+ ] {
+ apply_rollout_item(
+ &mut metadata,
+ &RolloutItem::EventMsg(event),
+ "test-provider",
+ );
+ assert_eq!(metadata, expected);
+ }
+
+ let mut existing = metadata.clone();
+ existing.title = "Named Guardian review".to_string();
+ metadata.prefer_existing_explicit_title(&existing);
+ assert_eq!(metadata, existing);
+
+ metadata.name = Some("Named Guardian review".to_string());
+ let expected = metadata.clone();
+ apply_rollout_item(&mut metadata, &session_meta, "test-provider");
+ assert_eq!(metadata, expected);
+ }
+
#[test]
fn event_msg_image_only_user_message_sets_image_placeholder_preview() {
let mut metadata = metadata_for_test();
diff --git a/codex-rs/state/src/lib.rs b/codex-rs/state/src/lib.rs
index 9e5b341686..6d88091b2f 100644
--- a/codex-rs/state/src/lib.rs
+++ b/codex-rs/state/src/lib.rs
@@ -38,10 +38,13 @@ pub use sqlite::SqliteConfig;
pub use audit::ThreadStateAuditRow;
pub use audit::read_thread_state_audit_rows;
+pub use extract::GUARDIAN_THREAD_PREVIEW;
+pub use extract::GUARDIAN_THREAD_TITLE;
/// Low-level storage engine: useful for focused tests.
///
/// Most consumers should prefer [`StateRuntime`].
pub use extract::apply_rollout_item;
+pub use extract::is_guardian_review_source;
pub use extract::rollout_item_affects_thread_metadata;
pub use model::AddThreadAttachmentOutcome;
pub use model::Anchor;
diff --git a/codex-rs/state/src/model/thread_metadata.rs b/codex-rs/state/src/model/thread_metadata.rs
index 2242c32625..a1b900af95 100644
--- a/codex-rs/state/src/model/thread_metadata.rs
+++ b/codex-rs/state/src/model/thread_metadata.rs
@@ -295,6 +295,7 @@ impl ThreadMetadataBuilder {
.recency_at
.map(canonicalize_datetime)
.unwrap_or(updated_at);
+ let guardian_review = crate::is_guardian_review_source(&self.source);
ThreadMetadata {
originator: self.originator.clone(),
creator_user_id: self.creator_user_id.clone(),
@@ -321,9 +322,14 @@ impl ThreadMetadataBuilder {
reasoning_effort: None,
cwd: self.cwd.clone(),
cli_version: self.cli_version.clone().unwrap_or_default(),
- title: String::new(),
- name: None,
- preview: None,
+ title: if guardian_review {
+ crate::GUARDIAN_THREAD_TITLE.to_string()
+ } else {
+ String::new()
+ },
+ name: (guardian_review && self.history_mode == ThreadHistoryMode::Paginated)
+ .then(|| crate::GUARDIAN_THREAD_TITLE.to_string()),
+ preview: guardian_review.then(|| crate::GUARDIAN_THREAD_PREVIEW.to_string()),
sandbox_policy,
approval_mode,
tokens_used: 0,
@@ -377,7 +383,11 @@ impl ThreadMetadata {
}
let title = self.title.trim();
- if title.is_empty() || self.first_user_message.as_deref().map(str::trim) == Some(title) {
+ if title.is_empty()
+ || self.first_user_message.as_deref().map(str::trim) == Some(title)
+ || (title == crate::GUARDIAN_THREAD_TITLE
+ && crate::extract::metadata_is_guardian_review(self))
+ {
self.title = existing.title.clone();
}
}
diff --git a/codex-rs/state/src/runtime/threads.rs b/codex-rs/state/src/runtime/threads.rs
index 2917fc2499..18225f020c 100644
--- a/codex-rs/state/src/runtime/threads.rs
+++ b/codex-rs/state/src/runtime/threads.rs
@@ -74,7 +74,7 @@ WHERE threads.id = ?
) -> anyhow::Result<bool> {
// Legacy threads display `title`, then fall back to the name index. Paginated threads
// display `name`; `title` remains derived metadata used for search. Preserve an existing
- // `name`, otherwise carry over the legacy display name.
+ // `name`, unless it is the Guardian default seeded by metadata cleanup.
let result = sqlx::query(
r#"
UPDATE threads
@@ -82,12 +82,17 @@ SET
history_mode = 'paginated',
name = CASE
WHEN name IS NULL OR trim(name) = '' THEN ?
+ WHEN history_mode = 'legacy'
+ AND source = '{"subagent":{"other":"guardian"}}'
+ AND name = ? THEN COALESCE(?, name)
ELSE name
END
WHERE id = ?
"#,
)
.bind(legacy_name)
+ .bind(crate::GUARDIAN_THREAD_TITLE)
+ .bind(legacy_name)
.bind(thread_id.to_string())
.execute(self.pool.as_ref())
.await?;
diff --git a/codex-rs/thread-store/src/local/helpers.rs b/codex-rs/thread-store/src/local/helpers.rs
index 86fc9b9fd4..96b92b1314 100644
--- a/codex-rs/thread-store/src/local/helpers.rs
+++ b/codex-rs/thread-store/src/local/helpers.rs
@@ -159,7 +159,8 @@ pub(super) fn stored_thread_from_rollout_item(
forked_from_id: None,
parent_thread_id: item.parent_thread_id,
preview,
- name: None,
+ name: codex_state::is_guardian_review_source(&source)
+ .then(|| codex_state::GUARDIAN_THREAD_TITLE.to_string()),
model_provider: item
.model_provider
.filter(|provider| !provider.is_empty())
@@ -241,13 +242,15 @@ pub(super) async fn resolve_thread_names(
store: &LocalThreadStore,
thread_history_modes: &HashMap<ThreadId, ThreadHistoryMode>,
) -> HashMap<ThreadId, String> {
- let mut names = HashMap::<ThreadId, String>::with_capacity(thread_history_modes.len());
let legacy_thread_ids = thread_history_modes
.iter()
.filter_map(|(&thread_id, &history_mode)| {
(history_mode == ThreadHistoryMode::Legacy).then_some(thread_id)
})
.collect::<HashSet<_>>();
+ let mut names = find_thread_names_by_ids(store.config.codex_home.as_path(), &legacy_thread_ids)
+ .await
+ .unwrap_or_default();
if let Some(state_db_ctx) = store.state_db().await {
for (&thread_id, &history_mode) in thread_history_modes {
let Ok(Some(metadata)) = state_db_ctx.get_thread(thread_id).await else {
@@ -258,22 +261,27 @@ pub(super) async fn resolve_thread_names(
ThreadHistoryMode::Paginated => sqlite_thread_name(&metadata),
};
if let Some(name) = name {
- names.insert(thread_id, name);
+ if history_mode == ThreadHistoryMode::Legacy
+ && has_guardian_default_title(&metadata)
+ {
+ names.entry(thread_id).or_insert(name);
+ } else {
+ names.insert(thread_id, name);
+ }
}
}
}
- if let Ok(legacy_names) =
- find_thread_names_by_ids(store.config.codex_home.as_path(), &legacy_thread_ids).await
- {
- // Legacy titles remain authoritative when present; the index only fills
- // names for threads whose SQLite title is still derived from the preview.
- for (thread_id, name) in legacy_names {
- names.entry(thread_id).or_insert(name);
- }
- }
names
}
+/// Identifies the derived Guardian label, which must yield to legacy indexed names.
+pub(super) fn has_guardian_default_title(metadata: &ThreadMetadata) -> bool {
+ metadata.title.trim() == codex_state::GUARDIAN_THREAD_TITLE
+ && serde_json::from_str::<SessionSource>(&metadata.source)
+ .as_ref()
+ .is_ok_and(codex_state::is_guardian_review_source)
+}
+
pub(super) fn distinct_thread_metadata_title(metadata: &ThreadMetadata) -> Option<String> {
let title = metadata.title.trim();
if title.is_empty() || metadata.first_user_message.as_deref().map(str::trim) == Some(title) {
@@ -340,6 +348,7 @@ fn thread_id_from_rollout_path(path: &Path) -> Option<ThreadId> {
#[cfg(test)]
mod tests {
+ use codex_protocol::protocol::SubAgentSource;
use codex_rollout::ThreadItem;
use pretty_assertions::assert_eq;
use uuid::Uuid;
@@ -347,7 +356,7 @@ mod tests {
use super::*;
#[test]
- fn stored_thread_from_rollout_item_returns_logical_rollout_path() {
+ fn guardian_rollout_conversion_preserves_name_and_logical_path() {
let uuid = Uuid::from_u128(1);
let compressed_path = PathBuf::from(format!(
"/tmp/sessions/2025/01/03/rollout-2025-01-03T12-00-00-{uuid}.jsonl.zst"
@@ -355,6 +364,9 @@ mod tests {
let thread = stored_thread_from_rollout_item(
ThreadItem {
path: compressed_path.clone(),
+ source: Some(SessionSource::SubAgent(SubAgentSource::Other(
+ "guardian".to_string(),
+ ))),
..Default::default()
},
/*archived*/ false,
@@ -362,6 +374,7 @@ mod tests {
)
.expect("stored thread");
+ assert_eq!(thread.name.as_deref(), Some("Guardian review"));
assert_eq!(
thread.rollout_path,
Some(
diff --git a/codex-rs/thread-store/src/local/read_thread.rs b/codex-rs/thread-store/src/local/read_thread.rs
index a14dcd8c52..2c613b0f0d 100644
--- a/codex-rs/thread-store/src/local/read_thread.rs
+++ b/codex-rs/thread-store/src/local/read_thread.rs
@@ -14,6 +14,7 @@ use codex_state::ThreadMetadata;
use super::LocalThreadStore;
use super::helpers::distinct_thread_metadata_title;
use super::helpers::git_info_from_parts;
+use super::helpers::has_guardian_default_title;
use super::helpers::permission_profile_from_metadata_value;
use super::helpers::rollout_path_is_archived;
use super::helpers::set_thread_name;
@@ -437,14 +438,16 @@ async fn thread_name_from_metadata(
match history_mode {
ThreadHistoryMode::Paginated => sqlite_thread_name(metadata),
ThreadHistoryMode::Legacy => {
- if let Some(title) = distinct_thread_metadata_title(metadata) {
- Some(title)
+ let title = distinct_thread_metadata_title(metadata);
+ if title.is_some() && !has_guardian_default_title(metadata) {
+ title
} else {
find_thread_name_by_id(store.config.codex_home.as_path(), &metadata.id)
.await
.ok()
.flatten()
.filter(|name| !name.trim().is_empty())
+ .or(title)
}
}
}
diff --git a/codex-rs/thread-store/src/local/rollout_migration.rs b/codex-rs/thread-store/src/local/rollout_migration.rs
index 59eaede016..ef7d9aec43 100644
--- a/codex-rs/thread-store/src/local/rollout_migration.rs
+++ b/codex-rs/thread-store/src/local/rollout_migration.rs
@@ -35,6 +35,7 @@ use tokio::time::Instant;
use super::LocalThreadStore;
use super::helpers::distinct_thread_metadata_title;
+use super::helpers::has_guardian_default_title;
use super::thread_history;
use super::thread_history::ProjectedRolloutLine;
use super::thread_history::RolloutProjectionStep;
@@ -1103,9 +1104,14 @@ impl LocalThreadStore {
{
return Ok(());
}
- let legacy_name = distinct_thread_metadata_title(&metadata)
- .or_else(|| legacy_names.get(&thread_id).cloned())
- .filter(|name| !name.trim().is_empty());
+ let title = distinct_thread_metadata_title(&metadata);
+ let indexed_name = legacy_names.get(&thread_id).cloned();
+ let legacy_name = if has_guardian_default_title(&metadata) {
+ indexed_name.or(title)
+ } else {
+ title.or(indexed_name)
+ }
+ .filter(|name| !name.trim().is_empty());
if !state_db
.mark_thread_paginated(thread_id, legacy_name.as_deref())
.await
diff --git a/codex-rs/thread-store/src/local/rollout_migration_tests.rs b/codex-rs/thread-store/src/local/rollout_migration_tests.rs
index 7c85b6b080..4a5a9d2c9c 100644
--- a/codex-rs/thread-store/src/local/rollout_migration_tests.rs
+++ b/codex-rs/thread-store/src/local/rollout_migration_tests.rs
@@ -2206,7 +2206,7 @@ async fn migration_preserves_legacy_displayed_thread_names() {
write_rollout(
home.path(),
title_thread_id,
- SessionSource::Cli,
+ SessionSource::SubAgent(SubAgentSource::Other("guardian".to_string())),
vec![user_message("title question")],
);
let index_thread_id = ThreadId::new();
@@ -2216,6 +2216,16 @@ async fn migration_preserves_legacy_displayed_thread_names() {
SessionSource::Cli,
vec![user_message("index question")],
);
+ let guardian_thread_id = ThreadId::new();
+ let unnamed_guardian_thread_id = ThreadId::new();
+ for thread_id in [guardian_thread_id, unnamed_guardian_thread_id] {
+ write_rollout(
+ home.path(),
+ thread_id,
+ SessionSource::SubAgent(SubAgentSource::Other("guardian".to_string())),
+ vec![user_message("large synthetic Guardian prompt")],
+ );
+ }
let store = indexed_store(home.path()).await;
store
.update_thread_metadata(UpdateThreadMetadataParams {
@@ -2235,42 +2245,77 @@ async fn migration_preserves_legacy_displayed_thread_names() {
.await
.expect("write legacy index name");
- store
- .migrate_rollouts(apply_options())
+ // Older metadata cleanup also seeded the default name on legacy threads.
+ let state_db = store.state_db().await.expect("state runtime");
+ let mut guardian_metadata = state_db
+ .get_thread(guardian_thread_id)
.await
- .expect("migrate named rollouts");
-
- let page = store
- .list_threads(ListThreadsParams {
- page_size: 10,
- cursor: None,
- sort_key: ThreadSortKey::CreatedAt,
- sort_direction: SortDirection::Desc,
- allowed_sources: Vec::new(),
- model_providers: None,
- cwd_filters: None,
- section: None,
- project_id: None,
- archived: false,
- search_term: None,
- relation_filter: None,
- use_state_db_only: true,
- })
+ .expect("read Guardian metadata")
+ .expect("Guardian metadata");
+ guardian_metadata.name = Some(codex_state::GUARDIAN_THREAD_TITLE.to_string());
+ state_db
+ .upsert_thread(&guardian_metadata)
.await
- .expect("list migrated threads");
- let title_thread = page
- .items
- .iter()
- .find(|thread| thread.thread_id == title_thread_id)
- .expect("renamed title thread");
- let index_thread = page
- .items
- .iter()
- .find(|thread| thread.thread_id == index_thread_id)
- .expect("indexed title thread");
+ .expect("seed legacy Guardian name");
+ codex_rollout::append_thread_name(home.path(), guardian_thread_id, "indexed Guardian name")
+ .await
+ .expect("write legacy Guardian name");
- assert_eq!(title_thread.name.as_deref(), Some("renamed title"));
- assert_eq!(index_thread.name.as_deref(), Some("indexed title"));
+ for history_mode in [ThreadHistoryMode::Legacy, ThreadHistoryMode::Paginated] {
+ if history_mode == ThreadHistoryMode::Paginated {
+ store
+ .migrate_rollouts(apply_options())
+ .await
+ .expect("migrate named rollouts");
+ }
+ let page = store
+ .list_threads(ListThreadsParams {
+ page_size: 10,
+ cursor: None,
+ sort_key: ThreadSortKey::CreatedAt,
+ sort_direction: SortDirection::Desc,
+ allowed_sources: Vec::new(),
+ model_providers: None,
+ cwd_filters: None,
+ section: None,
+ project_id: None,
+ archived: false,
+ search_term: None,
+ relation_filter: None,
+ use_state_db_only: true,
+ })
+ .await
+ .expect("list threads");
+ for (thread_id, name) in [
+ (title_thread_id, "renamed title"),
+ (index_thread_id, "indexed title"),
+ (guardian_thread_id, "indexed Guardian name"),
+ (unnamed_guardian_thread_id, "Guardian review"),
+ ] {
+ let listed = page
+ .items
+ .iter()
+ .find(|thread| thread.thread_id == thread_id)
+ .expect("listed thread");
+ let read = store
+ .read_thread(crate::ReadThreadParams {
+ thread_id,
+ include_archived: false,
+ include_history: false,
+ })
+ .await
+ .expect("read thread");
+ assert_eq!(
+ (
+ listed.name.as_deref(),
+ read.name.as_deref(),
+ listed.history_mode,
+ read.history_mode
+ ),
+ (Some(name), Some(name), history_mode, history_mode),
+ );
+ }
+ }
}
#[tokio::test]
diff --git a/codex-rs/thread-store/src/thread_metadata_sync.rs b/codex-rs/thread-store/src/thread_metadata_sync.rs
index 54350fbc68..3bf2937417 100644
--- a/codex-rs/thread-store/src/thread_metadata_sync.rs
+++ b/codex-rs/thread-store/src/thread_metadata_sync.rs
@@ -10,6 +10,7 @@ use codex_protocol::ThreadId;
use codex_protocol::items::TurnItem;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::GitInfo;
+use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::ThreadHistoryMode;
use codex_protocol::protocol::ThreadMemoryMode;
use codex_protocol::protocol::UserMessageEvent;
@@ -62,7 +63,12 @@ impl ThreadMetadataSync {
} else {
None
};
+ let guardian_review = codex_state::is_guardian_review_source(&params.source);
let update = ThreadMetadataPatch {
+ name: (guardian_review && params.history_mode == ThreadHistoryMode::Paginated)
+ .then(|| Some(codex_state::GUARDIAN_THREAD_TITLE.to_string())),
+ title: guardian_review.then(|| codex_state::GUARDIAN_THREAD_TITLE.to_string()),
+ preview: guardian_review.then(|| codex_state::GUARDIAN_THREAD_PREVIEW.to_string()),
model_provider: Some(params.metadata.model_provider.clone()),
created_at: Some(created_at),
updated_at: Some(created_at),
@@ -83,9 +89,9 @@ impl ThreadMetadataSync {
Self {
thread_id: params.thread_id,
cwd_seen: !cwd.as_os_str().is_empty(),
- preview_seen: false,
- first_user_message_seen: false,
- title_seen: false,
+ preview_seen: guardian_review,
+ first_user_message_seen: guardian_review,
+ title_seen: guardian_review,
pending_update: Some(update),
pending_update_generation: 1,
last_touch_persisted_at: None,
@@ -98,6 +104,11 @@ impl ThreadMetadataSync {
params: &ResumeThreadParams,
metadata: Option<&ThreadMetadata>,
) -> Self {
+ let guardian_review = metadata.is_some_and(|metadata| {
+ serde_json::from_str::<SessionSource>(&metadata.source)
+ .as_ref()
+ .is_ok_and(codex_state::is_guardian_review_source)
+ });
let mut sync = Self {
thread_id: params.thread_id,
cwd_seen: params
@@ -105,12 +116,14 @@ impl ThreadMetadataSync {
.cwd
.as_ref()
.is_some_and(|cwd| !cwd.as_os_str().is_empty()),
- preview_seen: metadata
- .and_then(|metadata| metadata.preview.as_deref())
- .is_some_and(|preview| !preview.is_empty()),
- first_user_message_seen: metadata
- .is_some_and(|metadata| metadata.first_user_message.is_some()),
- title_seen: metadata.is_some_and(|metadata| !metadata.title.is_empty()),
+ preview_seen: guardian_review
+ || metadata
+ .and_then(|metadata| metadata.preview.as_deref())
+ .is_some_and(|preview| !preview.is_empty()),
+ first_user_message_seen: guardian_review
+ || metadata.is_some_and(|metadata| metadata.first_user_message.is_some()),
+ title_seen: guardian_review
+ || metadata.is_some_and(|metadata| !metadata.title.is_empty()),
pending_update: None,
pending_update_generation: 0,
last_touch_persisted_at: None,
@@ -229,6 +242,13 @@ impl ThreadMetadataSync {
for item in items {
match item {
RolloutItem::SessionMeta(meta_line) if meta_line.meta.id == self.thread_id => {
+ // Never derive display metadata from the synthetic prompt.
+ if codex_state::is_guardian_review_source(&meta_line.meta.source) {
+ self.preview_seen = true;
+ self.first_user_message_seen = true;
+ self.title_seen = true;
+ update.preview = Some(codex_state::GUARDIAN_THREAD_PREVIEW.to_string());
+ }
update.created_at = parse_session_timestamp(meta_line.meta.timestamp.as_str());
update.creator_user_id = meta_line.meta.creator_user_id.clone();
update.creator_account_id = meta_line.meta.creator_account_id.clone();
@@ -275,7 +295,9 @@ impl ThreadMetadataSync {
self.observe_user_message(user, &mut update);
}
RolloutItem::EventMsg(EventMsg::ItemCompleted(event)) => {
- if let TurnItem::UserMessage(user) = &event.item {
+ if let TurnItem::UserMessage(user) = &event.item
+ && (!self.first_user_message_seen || !self.preview_seen || !self.title_seen)
+ {
self.observe_user_message(
&user.as_legacy_user_message_event(),
&mut update,
@@ -323,7 +345,9 @@ impl ThreadMetadataSync {
}
fn observe_user_message(&mut self, user: &UserMessageEvent, update: &mut ThreadMetadataPatch) {
- if let Some(preview) = user_message_preview(user) {
+ if (!self.first_user_message_seen || !self.preview_seen)
+ && let Some(preview) = user_message_preview(user)
+ {
if !self.first_user_message_seen {
self.first_user_message_seen = true;
update.first_user_message = Some(preview.clone());
@@ -431,6 +455,7 @@ mod tests {
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
+ use codex_protocol::protocol::SubAgentSource;
use codex_protocol::protocol::ThreadGoal;
use codex_protocol::protocol::ThreadGoalStatus;
use codex_protocol::protocol::ThreadGoalUpdatedEvent;
@@ -484,6 +509,44 @@ mod tests {
);
}
+ #[test]
+ fn guardian_resume_without_session_meta_preserves_compact_metadata() {
+ let thread_id = ThreadId::new();
+ let mut metadata = codex_state::ThreadMetadataBuilder::new(
+ thread_id,
+ Default::default(),
+ Utc::now(),
+ SessionSource::SubAgent(SubAgentSource::Other("guardian".to_string())),
+ )
+ .build("test-provider");
+ metadata.history_mode = ThreadHistoryMode::Paginated;
+
+ let sync = ThreadMetadataSync::for_resume(
+ &resume_params(
+ thread_id,
+ vec![RolloutItem::EventMsg(EventMsg::ItemCompleted(
+ ItemCompletedEvent {
+ thread_id,
+ turn_id: "turn-1".to_string(),
+ item: TurnItem::UserMessage(UserMessageItem::new(&[UserInput::Text {
+ text: "large synthetic guardian prompt".to_string(),
+ text_elements: Vec::new(),
+ }])),
+ started_at_ms: Some(0),
+ completed_at_ms: 0,
+ },
+ ))],
+ ),
+ Some(&metadata),
+ );
+
+ let update = sync.take_pending_update().expect("pending metadata update");
+ assert_eq!(update.patch.name, None);
+ assert_eq!(update.patch.title, None);
+ assert_eq!(update.patch.preview, None);
+ assert_eq!(update.patch.first_user_message, None);
+ }
+
#[test]
fn resume_history_keeps_derived_metadata_pending_until_applied() {
let thread_id = ThreadId::new();