Lightweight coding agent that runs in your terminal
Rust
Preserve thread metadata before rollout files are materialized (#55380)
jif1e4ba692b841
diff --git a/codex-rs/app-server/tests/suite/v2/thread_fork.rs b/codex-rs/app-server/tests/suite/v2/thread_fork.rsindex 9182245cf1..b3f473496c 100644--- a/codex-rs/app-server/tests/suite/v2/thread_fork.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_fork.rs@@ -1475,8 +1475,10 @@ async fn thread_fork_tracks_thread_initialized_analytics() -> Result<()> {Ok(())}+#[test_case(ThreadHistoryMode::Legacy; "legacy")]+#[test_case(ThreadHistoryMode::Paginated; "paginated")]#[tokio::test]-async fn thread_fork_rejects_unmaterialized_thread() -> Result<()> {+async fn thread_fork_rejects_unmaterialized_thread(history_mode: ThreadHistoryMode) -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;let codex_home = TempDir::new()?;MockResponsesConfig::new(&server.uri()).write(codex_home.path())?;@@ -1489,6 +1491,7 @@ async fn thread_fork_rejects_unmaterialized_thread() -> Result<()> {let start_id = mcp.send_thread_start_request_with_auto_env(ThreadStartParams {model: Some("mock-model".to_string()),+ history_mode: Some(history_mode),..Default::default()}).await?;diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rsindex 20649549fd..c34a453e6c 100644--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs@@ -447,8 +447,15 @@ async fn wait_for_responses_request_count(Ok(())}+#[test_case(ThreadHistoryMode::Legacy, false; "legacy with turns")]+#[test_case(ThreadHistoryMode::Legacy, true; "legacy without turns")]+#[test_case(ThreadHistoryMode::Paginated, false; "paginated with turns")]+#[test_case(ThreadHistoryMode::Paginated, true; "paginated without turns")]#[tokio::test]-async fn thread_resume_rejects_unmaterialized_thread() -> Result<()> {+async fn thread_resume_rejects_unmaterialized_thread(+ history_mode: ThreadHistoryMode,+ exclude_turns: bool,+) -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;let codex_home = TempDir::new()?;mock_responses_config(&server.uri()).write(codex_home.path())?;@@ -462,6 +469,7 @@ async fn thread_resume_rejects_unmaterialized_thread() -> Result<()> {let start_id = mcp.send_thread_start_request_with_auto_env(ThreadStartParams {model: Some("gpt-5.4".to_string()),+ history_mode: Some(history_mode),..Default::default()}).await?;@@ -472,6 +480,7 @@ async fn thread_resume_rejects_unmaterialized_thread() -> Result<()> {let resume_id = mcp.send_thread_resume_request(ThreadResumeParams {thread_id: thread.id.clone(),+ exclude_turns,..Default::default()}).await?;diff --git a/codex-rs/rollout/src/recorder.rs b/codex-rs/rollout/src/recorder.rsindex 4dbd9e5fe1..b02229a377 100644--- a/codex-rs/rollout/src/recorder.rs+++ b/codex-rs/rollout/src/recorder.rs@@ -127,6 +127,9 @@ pub enum RolloutRecorderParams {enum RolloutCmd {AddItems(Vec<RolloutItem>),+ ReadUnpersistedSessionMeta {+ ack: oneshot::Sender<Option<SessionMeta>>,+ },Persist {ack: oneshot::Sender<std::io::Result<()>>,},@@ -1045,6 +1048,19 @@ impl RolloutRecorder {self.rollout_path.as_path()}+ /// Reads the creation metadata while this writer still defers its rollout file.+ ///+ /// The writer orders this read with persistence. Resumed or already materialized rollouts+ /// return `None`, so callers must keep using their durable metadata.+ pub async fn unpersisted_session_meta(&self) -> std::io::Result<Option<SessionMeta>> {+ let (ack, result) = oneshot::channel();+ self.tx+ .send(RolloutCmd::ReadUnpersistedSessionMeta { ack })+ .await+ .map_err(IoError::other)?;+ result.await.map_err(IoError::other)+ }+pub async fn record_canonical_items(&self, items: &[RolloutItem]) -> std::io::Result<()> {if items.is_empty() {return Ok(());@@ -1966,6 +1982,14 @@ async fn rollout_writer(// Process rollout commandswhile let Some(cmd) = rx.recv().await {match cmd {+ RolloutCmd::ReadUnpersistedSessionMeta { ack } => {+ let metadata = if state.is_deferred() {+ state.meta.clone()+ } else {+ None+ };+ let _ = ack.send(metadata);+ }RolloutCmd::AddItems(items) => {state.add_items(items);state.flush_if_materialized().await;diff --git a/codex-rs/rollout/src/recorder_tests.rs b/codex-rs/rollout/src/recorder_tests.rsindex e440aa1617..7e7767ec0f 100644--- a/codex-rs/rollout/src/recorder_tests.rs+++ b/codex-rs/rollout/src/recorder_tests.rs@@ -822,10 +822,20 @@ async fn referenced_paginated_rollout_starts_at_history_cutoff_and_resumes() ->).await?;let rollout_path = recorder.rollout_path().to_path_buf();+ let initial_meta = recorder+ .unpersisted_session_meta()+ .await?+ .expect("new rollout retains its creation metadata");+ assert!(!rollout_path.exists());recorder.persist().await?;+ assert!(recorder.unpersisted_session_meta().await?.is_none());recorder.shutdown().await?;let meta = crate::read_session_meta_line(&rollout_path).await?.meta;+ assert_eq!(+ serde_json::to_value(&initial_meta)?,+ serde_json::to_value(&meta)?+ );assert_eq!(meta.forked_from_ordinal_exclusive,Some(history_base.end_ordinal_exclusive)@@ -833,6 +843,7 @@ async fn referenced_paginated_rollout_starts_at_history_cutoff_and_resumes() ->let resumed =RolloutRecorder::new(&config, RolloutRecorderParams::resume(rollout_path.clone())).await?;+ assert!(resumed.unpersisted_session_meta().await?.is_none());resumed.record_canonical_items(&[agent_message_item("first child record")]).await?;diff --git a/codex-rs/thread-store/src/local/live_writer.rs b/codex-rs/thread-store/src/local/live_writer.rsindex e1b49e82b7..a8213b8845 100644--- a/codex-rs/thread-store/src/local/live_writer.rs+++ b/codex-rs/thread-store/src/local/live_writer.rs@@ -2,6 +2,7 @@ use std::path::PathBuf;use std::sync::Arc;use codex_protocol::ThreadId;+use codex_protocol::protocol::SessionMeta;use codex_protocol::protocol::ThreadHistoryMode;use codex_protocol::protocol::ThreadMemoryMode;use codex_rollout::RolloutConfig;@@ -324,6 +325,24 @@ pub(super) async fn live_writer_parts(Ok((entry.recorder.clone(), entry.rollout_id, entry.history_mode))}+/// Uses the writer's creation record only until its rollout has been materialized.+pub(super) async fn unpersisted_session_meta(+ store: &LocalThreadStore,+ thread_id: ThreadId,+) -> Option<(PathBuf, SessionMeta)> {+ let (recorder, _, _) = live_writer_parts(store, thread_id).await.ok()?;+ // Materialized reads should not queue behind unrelated transcript writes.+ if codex_rollout::existing_rollout_path(recorder.rollout_path())+ .await+ .is_some()+ {+ return None;+ }+ // A writer may finish shutdown after lookup; durable reads remain the fallback.+ let meta = recorder.unpersisted_session_meta().await.ok()??;+ Some((recorder.rollout_path().to_path_buf(), meta))+}+async fn write_and_project(store: &LocalThreadStore,thread_id: ThreadId,diff --git a/codex-rs/thread-store/src/local/pending_thread_metadata_tests.rs b/codex-rs/thread-store/src/local/pending_thread_metadata_tests.rsindex 4c26f48384..f9b4c63348 100644--- a/codex-rs/thread-store/src/local/pending_thread_metadata_tests.rs+++ b/codex-rs/thread-store/src/local/pending_thread_metadata_tests.rs@@ -233,6 +233,97 @@ async fn pending_rollout_compatible_metadata_is_written_with_observed_update() {assert_pending_metadata_consumed(&store, thread_id).await;}+#[tokio::test]+async fn deferred_reads_preserve_creation_metadata_and_updates() {+ for history_mode in [ThreadHistoryMode::Legacy, ThreadHistoryMode::Paginated] {+ let (_home, store, runtime) = store_with_runtime().await;+ let thread_id = ThreadId::new();+ let mut params = create_thread_params(thread_id);+ params.history_mode = history_mode;+ params.forked_from_id = Some(ThreadId::new());+ params.parent_thread_id = Some(ThreadId::new());+ let live_thread = LiveThread::create(store.clone(), params.clone())+ .await+ .expect("create live thread");+ let rollout_path = store+ .live_rollout_path(thread_id)+ .await+ .expect("live rollout path");+ let initial = live_thread+ .read_thread(+ /*include_archived*/ false, /*include_history*/ false,+ )+ .await+ .expect_err("untouched threads still have no stored record");+ assert!(matches!(+ initial,+ ThreadStoreError::InvalidRequest { message }+ if message == format!("no rollout found for thread id {thread_id}")+ ));+ assert!(!rollout_path.exists());+ assert_eq!(+ runtime.get_thread(thread_id).await.expect("read index"),+ None+ );++ let updated = live_thread+ .update_metadata(+ ThreadMetadataPatch {+ daybreak_enabled: Some(true),+ ..Default::default()+ },+ /*include_archived*/ false,+ )+ .await+ .expect("update metadata without materializing history");+ let read = live_thread+ .read_thread(+ /*include_archived*/ false, /*include_history*/ false,+ )+ .await+ .expect("read updated metadata");+ assert_eq!(+ serde_json::to_value(read).expect("serialize metadata read"),+ serde_json::to_value(&updated).expect("serialize update result")+ );+ assert_eq!(+ (+ updated.forked_from_id,+ updated.parent_thread_id,+ updated.originator.clone(),+ updated.history_mode,+ updated.daybreak_enabled,+ ),+ (+ params.forked_from_id,+ params.parent_thread_id,+ Some(params.originator),+ history_mode,+ Some(true),+ )+ );+ assert!(!rollout_path.exists());++ live_thread+ .persist(PersistContext::Standard)+ .await+ .expect("persist history");+ live_thread.shutdown().await.expect("shutdown writer");+ let durable = store+ .read_thread(ReadThreadParams {+ thread_id,+ include_archived: false,+ include_history: false,+ })+ .await+ .expect("read durable metadata");+ assert_eq!(+ serde_json::to_value(durable).expect("serialize durable metadata"),+ serde_json::to_value(updated).expect("serialize initial metadata")+ );+ }+}+#[tokio::test]async fn idle_shutdown_clears_pending_thread_metadata_without_materializing() {let (_home, store, runtime) = store_with_runtime().await;@@ -245,6 +336,24 @@ async fn idle_shutdown_clears_pending_thread_metadata_without_materializing() {let live_thread = LiveThread::create(store.clone(), create_thread_params(thread_id)).await.expect("create live thread");+ let read_error = live_thread+ .read_thread(+ /*include_archived*/ false, /*include_history*/ false,+ )+ .await+ .expect_err("untouched threads still have no stored record");+ assert!(matches!(+ read_error,+ ThreadStoreError::InvalidRequest { message }+ if message == format!("no rollout found for thread id {thread_id}")+ ));+ assert!(+ !store+ .live_rollout_path(thread_id)+ .await+ .expect("live rollout path")+ .exists()+ );live_thread.shutdown().await.expect("shutdown idle thread");assert_eq!(diff --git a/codex-rs/thread-store/src/local/read_thread.rs b/codex-rs/thread-store/src/local/read_thread.rsindex c5dd2e085d..13624f82c8 100644--- a/codex-rs/thread-store/src/local/read_thread.rs+++ b/codex-rs/thread-store/src/local/read_thread.rs@@ -2,6 +2,7 @@ use chrono::DateTime;use chrono::Utc;use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::AskForApproval;+use codex_protocol::protocol::SessionMeta;use codex_protocol::protocol::SessionMetaLine;use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::ThreadHistoryMode;@@ -34,6 +35,24 @@ pub(super) async fn read_thread() -> ThreadStoreResult<StoredThread> {let thread_id = params.thread_id;let sqlite_metadata = read_sqlite_metadata(store, thread_id).await;+ if !params.include_history+ && let Some((path, meta)) =+ super::live_writer::unpersisted_session_meta(store, thread_id).await+ && sqlite_metadata+ .as_ref()+ .is_none_or(|metadata| metadata.rollout_path == path && metadata.archived_at.is_none())+ {+ // A new writer already owns its metadata. Missing JSONL is intentional, so neither+ // filesystem discovery nor compression-race retries can find anything more authoritative.+ return match sqlite_metadata {+ Some(metadata) => Ok(stored_thread_from_metadata(store, metadata, Some(meta)).await),+ // Preserve the saved-thread contract used by fork/resume. A live but untouched+ // thread has no stored record yet; its absence is known without searching history.+ None => Err(ThreadStoreError::InvalidRequest {+ message: format!("no rollout found for thread id {thread_id}"),+ }),+ };+ }let persisted_model_settings = sqlite_metadata.as_ref().map(|metadata| (metadata.model.clone(), metadata.reasoning_effort.clone()));@@ -376,6 +395,14 @@ pub(super) async fn stored_thread_from_sqlite_metadata(});}};+ Ok(stored_thread_from_metadata(store, metadata, session_meta).await)+}++async fn stored_thread_from_metadata(+ store: &LocalThreadStore,+ metadata: ThreadMetadata,+ session_meta: Option<SessionMeta>,+) -> StoredThread {let forked_from_id = session_meta.as_ref().and_then(|meta| meta.forked_from_id);let parent_thread_id = session_meta.as_ref().and_then(|meta| meta.parent_thread_id);let history_mode = session_meta@@ -392,7 +419,7 @@ pub(super) async fn stored_thread_from_sqlite_metadata(thread.forked_from_id = forked_from_id;thread.history_mode = history_mode;thread.name = name;- Ok(thread)+ thread}pub(super) fn stored_thread_from_state_metadata(diff --git a/codex-rs/thread-store/src/local/update_thread_metadata.rs b/codex-rs/thread-store/src/local/update_thread_metadata.rsindex 393513eb99..9e72bcdf02 100644--- a/codex-rs/thread-store/src/local/update_thread_metadata.rs+++ b/codex-rs/thread-store/src/local/update_thread_metadata.rs@@ -695,6 +695,11 @@ async fn canonical_history_mode(thread_id: ThreadId,rollout_path: &Path,) -> ThreadStoreResult<ThreadHistoryMode> {+ if let Some((path, meta)) = live_writer::unpersisted_session_meta(store, thread_id).await+ && path == rollout_path+ {+ return Ok(meta.history_mode);+ }let session_meta = match read_session_meta_line(rollout_path).await {Ok(session_meta) => session_meta,Err(err) => {