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.rsindex 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.rsindex 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.rsindex 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<HeadTaisummary.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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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 @@ SEThistory_mode = 'paginated',name = CASEWHEN name IS NULL OR trim(name) = '' THEN ?+ WHEN history_mode = 'legacy'+ AND source = '{"subagent":{"other":"guardian"}}'+ AND name = ? THEN COALESCE(?, name)ELSE nameENDWHERE 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.rsindex 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.rsindex 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.rsindex 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()).awaitdiff --git a/codex-rs/thread-store/src/local/rollout_migration_tests.rs b/codex-rs/thread-store/src/local/rollout_migration_tests.rsindex 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.rsindex 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(¶ms.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();