Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Stop memory dual-write when v2 is selected (#55262)

jif71ab2ea77bc7
diff --git a/codex-rs/config/src/types.rs b/codex-rs/config/src/types.rs
index 8846fb3d95..5c0ebe0e3c 100644
--- a/codex-rs/config/src/types.rs
+++ b/codex-rs/config/src/types.rs
@@ -322,7 +322,7 @@ pub use codex_protocol::MemoryVersion;
pub struct MemoriesToml {
/// Selects the memory pipeline; v1 remains the default.
pub version: Option<MemoryVersion>,
- /// Generate both versions while the selected version supplies context.
+ /// Generate both versions while v1 is selected; v2 runs alone after cutover.
pub dual_write: Option<bool>,
/// When `true`, external context sources mark the thread `memory_mode` as `"polluted"`.
#[serde(alias = "no_memories_if_mcp_or_web_search")]
diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json
index 6ea1ea8e1b..e91aa7a3d5 100644
--- a/codex-rs/core/config.schema.json
+++ b/codex-rs/core/config.schema.json
@@ -2645,7 +2645,7 @@
"type": "boolean"
},
"dual_write": {
- "description": "Generate both versions while the selected version supplies context.",
+ "description": "Generate both versions while v1 is selected; v2 runs alone after cutover.",
"type": "boolean"
},
"extract_model": {
diff --git a/codex-rs/memories/write/src/start.rs b/codex-rs/memories/write/src/start.rs
index ebd0b9950e..102881cf6f 100644
--- a/codex-rs/memories/write/src/start.rs
+++ b/codex-rs/memories/write/src/start.rs
@@ -37,7 +37,8 @@ pub fn start_memories_startup_task(
return;
}
- let versions = if config.memories.dual_write {
+ // Dual-write warms v2 while v1 is selected; it is no longer needed after cutover.
+ let versions = if config.memories.dual_write && config.memories.version == MemoryVersion::V1 {
vec![MemoryVersion::V1, MemoryVersion::V2]
} else {
vec![config.memories.version]
diff --git a/codex-rs/memories/write/src/startup_dual_write_tests.rs b/codex-rs/memories/write/src/startup_dual_write_tests.rs
index 430fca52c3..9b62c3bc64 100644
--- a/codex-rs/memories/write/src/startup_dual_write_tests.rs
+++ b/codex-rs/memories/write/src/startup_dual_write_tests.rs
@@ -1,4 +1,4 @@
-//! Exercises both startup pipelines through model requests and committed versioned state.
+//! Exercises dual-write and v2 cutover through model requests and committed versioned state.
use super::*;
use codex_protocol::MemoryVersion;
@@ -9,104 +9,117 @@ use wiremock::matchers::method;
use wiremock::matchers::path_regex;
#[tokio::test]
-async fn dual_write_extracts_and_consolidates_into_independent_stores() -> anyhow::Result<()> {
- let server = start_mock_server().await;
- let home = Arc::new(TempDir::new()?);
- let mut memories = startup_test_memories_config();
- memories.dual_write = true;
- let test = build_test_codex_with_memories_config(&server, Arc::clone(&home), memories).await?;
- let db = test.codex.state_db().expect("memory state");
- let source = seed_stage1_candidate(
- &db,
- home.path(),
- chrono::Utc::now() - chrono::Duration::hours(2),
- "dual-write",
- )
- .await?;
- let v1_root = home.path().join("memories");
- let v2_root = home.path().join("memories_v2");
- seed_required_memory_artifacts(&v1_root).await?;
- tokio::fs::create_dir_all(&v2_root).await?;
- tokio::fs::write(
- v2_root.join("memory_summary.md"),
- "v1\n\n## User Profile\nV2 user\n\n## User preferences\nV2 preference\n\n## General Tips\nV2 tip\n\n## What's in Memory\nV2 source\n",
- )
- .await?;
- // Dispatch by the output contract rather than request order: both pipelines
- // run concurrently, and each phase two can start before the other phase one.
- Mock::given(method("POST"))
- .and(path_regex(".*/responses$"))
- .respond_with(|request: &wiremock::Request| {
- let body: serde_json::Value = request.body_json().expect("response request");
- let properties = &body["text"]["format"]["schema"]["properties"];
- let output = if properties.get("raw_memory").is_some() {
- r#"{"raw_memory":"legacy fact","rollout_summary":"legacy rollout","rollout_slug":"legacy"}"#
- } else if properties.get("rollout_summary").is_some() {
- r#"{"rollout_summary":"v2 rollout","rollout_slug":"v2"}"#
- } else {
- "consolidation complete"
- };
- sse_response(sse(vec![
- ev_response_created("response"),
- ev_assistant_message("message", output),
- ev_completed("response"),
- ]))
- })
- .mount(&server)
- .await;
+async fn dual_write_runs_both_versions_until_v2_is_selected() -> anyhow::Result<()> {
+ for (selected_version, expected_pipelines) in [(MemoryVersion::V1, 2), (MemoryVersion::V2, 1)] {
+ let server = start_mock_server().await;
+ let home = Arc::new(TempDir::new()?);
+ let mut memories = startup_test_memories_config();
+ memories.dual_write = true;
+ memories.version = selected_version;
+ let test =
+ build_test_codex_with_memories_config(&server, Arc::clone(&home), memories).await?;
+ let db = test.codex.state_db().expect("memory state");
+ let source = seed_stage1_candidate(
+ &db,
+ home.path(),
+ chrono::Utc::now() - chrono::Duration::hours(2),
+ "dual-write",
+ )
+ .await?;
+ let v1_root = home.path().join("memories");
+ let v2_root = home.path().join("memories_v2");
+ seed_required_memory_artifacts(&v1_root).await?;
+ tokio::fs::create_dir_all(&v2_root).await?;
+ tokio::fs::write(
+ v2_root.join("memory_summary.md"),
+ "v1\n\n## User Profile\nV2 user\n\n## User preferences\nV2 preference\n\n## General Tips\nV2 tip\n\n## What's in Memory\nV2 source\n",
+ )
+ .await?;
+ // Dispatch by the output contract rather than request order: both pipelines
+ // run concurrently, and each phase two can start before the other phase one.
+ Mock::given(method("POST"))
+ .and(path_regex(".*/responses$"))
+ .respond_with(|request: &wiremock::Request| {
+ let body: serde_json::Value = request.body_json().expect("response request");
+ let properties = &body["text"]["format"]["schema"]["properties"];
+ let output = if properties.get("raw_memory").is_some() {
+ r#"{"raw_memory":"legacy fact","rollout_summary":"legacy rollout","rollout_slug":"legacy"}"#
+ } else if properties.get("rollout_summary").is_some() {
+ r#"{"rollout_summary":"v2 rollout","rollout_slug":"v2"}"#
+ } else {
+ "consolidation complete"
+ };
+ sse_response(sse(vec![
+ ev_response_created("response"),
+ ev_assistant_message("message", output),
+ ev_completed("response"),
+ ]))
+ })
+ .mount(&server)
+ .await;
- trigger_memories_startup(&test).await;
- for (version, root, expected_raw, expected_summary) in [
- (MemoryVersion::V1, &v1_root, "legacy fact", "legacy rollout"),
- (MemoryVersion::V2, &v2_root, "", "v2 rollout"),
- ] {
- let store = db.memories_for_version(version).await?;
- // Both pipelines initialize Git workspaces and run consolidation agents.
- // Allow for process startup under contention on Windows CI runners.
- let deadline = Instant::now() + Duration::from_secs(60);
- while store.max_consolidated_thread_count().await? == 0 {
- anyhow::ensure!(
- Instant::now() < deadline,
- "pipeline {version:?} did not consolidate"
+ trigger_memories_startup(&test).await;
+ for (version, root, expected_raw, expected_summary) in [
+ (MemoryVersion::V2, &v2_root, "", "v2 rollout"),
+ (MemoryVersion::V1, &v1_root, "legacy fact", "legacy rollout"),
+ ] {
+ let store = db.memories_for_version(version).await?;
+ if selected_version == MemoryVersion::V2 && version == MemoryVersion::V1 {
+ assert_eq!(
+ store.list_stage1_outputs_for_global(/*n*/ 10).await?,
+ vec![]
+ );
+ assert_eq!(store.max_consolidated_thread_count().await?, 0);
+ assert!(!root.join("rollout_summaries").exists());
+ continue;
+ }
+ // Both pipelines initialize Git workspaces and run consolidation agents.
+ // Allow for process startup under contention on Windows CI runners.
+ let deadline = Instant::now() + Duration::from_secs(60);
+ while store.max_consolidated_thread_count().await? == 0 {
+ anyhow::ensure!(
+ Instant::now() < deadline,
+ "pipeline {version:?} did not consolidate"
+ );
+ tokio::time::sleep(Duration::from_millis(50)).await;
+ }
+ let outputs = store.list_stage1_outputs_for_global(/*n*/ 10).await?;
+ assert_eq!(
+ outputs
+ .iter()
+ .map(|output| (
+ output.thread_id,
+ output.raw_memory.as_str(),
+ output.rollout_summary.as_str()
+ ))
+ .collect::<Vec<_>>(),
+ vec![(source, expected_raw, expected_summary)]
);
- tokio::time::sleep(Duration::from_millis(50)).await;
+ let summaries = read_rollout_summary_bodies(root).await?;
+ assert_eq!(summaries.len(), 1);
+ assert!(summaries[0].contains(expected_summary));
}
- let outputs = store.list_stage1_outputs_for_global(/*n*/ 10).await?;
+ let requests = server.received_requests().await.expect("recorded requests");
+ let bodies = requests
+ .iter()
+ .filter(|request| request.url.path().ends_with("/responses"))
+ .map(|request| {
+ request
+ .body_json::<serde_json::Value>()
+ .expect("request JSON")
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(bodies.len(), expected_pipelines * 2);
assert_eq!(
- outputs
+ bodies
.iter()
- .map(|output| (
- output.thread_id,
- output.raw_memory.as_str(),
- output.rollout_summary.as_str()
- ))
- .collect::<Vec<_>>(),
- vec![(source, expected_raw, expected_summary)]
+ .filter(|body| body["text"]["format"]["schema"].is_null())
+ .count(),
+ expected_pipelines
);
- let summaries = read_rollout_summary_bodies(root).await?;
- assert_eq!(summaries.len(), 1);
- assert!(summaries[0].contains(expected_summary));
+ assert!(!v2_root.join("MEMORY.md").exists());
+ assert!(!v2_root.join("raw_memories.md").exists());
+ shutdown_test_codex(&test).await?;
}
- let requests = server.received_requests().await.expect("recorded requests");
- let bodies = requests
- .iter()
- .filter(|request| request.url.path().ends_with("/responses"))
- .map(|request| {
- request
- .body_json::<serde_json::Value>()
- .expect("request JSON")
- })
- .collect::<Vec<_>>();
- assert_eq!(bodies.len(), 4);
- assert_eq!(
- bodies
- .iter()
- .filter(|body| body["text"]["format"]["schema"].is_null())
- .count(),
- 2
- );
- assert!(!v2_root.join("MEMORY.md").exists());
- assert!(!v2_root.join("raw_memories.md").exists());
- shutdown_test_codex(&test).await?;
Ok(())
}