Lightweight coding agent that runs in your terminal
Rust
Add memory dual writing and v2 readiness reporting (#43827)
jif2cbbf0c9b542
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex edd0687601..397ba2f016 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/src/protocol/common.rs b/codex-rs/app-server-protocol/src/protocol/common.rsindex a718641f7a..005e14a3ca 100644--- a/codex-rs/app-server-protocol/src/protocol/common.rs+++ b/codex-rs/app-server-protocol/src/protocol/common.rs@@ -681,6 +681,12 @@ client_request_definitions! {serialization: thread_id(params.thread_id),response: v2::ThreadMemoryModeSetResponse,},+ #[experimental("memory/status")]+ MemoryStatus => "memory/status" {+ params: v2::MemoryStatusParams,+ serialization: global("memory"),+ response: v2::MemoryStatusResponse,+ },#[experimental("memory/reset")]MemoryReset => "memory/reset" {params: #[ts(type = "undefined")] #[serde(skip_serializing_if = "Option::is_none")] Option<()>,diff --git a/codex-rs/app-server-protocol/src/protocol/v2/memory.rs b/codex-rs/app-server-protocol/src/protocol/v2/memory.rsnew file mode 100644index 0000000000..3e5ccc3a10--- /dev/null+++ b/codex-rs/app-server-protocol/src/protocol/v2/memory.rs@@ -0,0 +1,23 @@+//! Readiness for selecting v2 memory context after background consolidation.++use crate::JsonSchema;+use crate::TS;+use serde::Deserialize;+use serde::Serialize;++#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]+#[serde(rename_all = "camelCase")]+#[ts(export_to = "v2/")]+pub struct MemoryStatusParams {+ /// Required distinct consolidated threads. Defaults to 20; supported range is 1..=4096.+ #[ts(optional = nullable)]+ pub min_consolidated_threads: Option<u32>,+}++#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]+#[serde(rename_all = "camelCase")]+#[ts(export_to = "v2/")]+pub struct MemoryStatusResponse {+ pub v2_consolidated_threads: u32,+ pub v2_ready: bool,+}diff --git a/codex-rs/app-server-protocol/src/protocol/v2/mod.rs b/codex-rs/app-server-protocol/src/protocol/v2/mod.rsindex 9c91c85c26..736c577706 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/mod.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/mod.rs@@ -19,6 +19,7 @@ mod fs;mod hook;mod item;mod mcp;+mod memory;mod model;mod notification;mod permissions;@@ -55,6 +56,7 @@ pub use fs::*;pub use hook::*;pub use item::*;pub use mcp::*;+pub use memory::*;pub use model::*;pub use notification::*;pub use permissions::*;diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rsindex 3557370eee..c462bb738f 100644--- a/codex-rs/app-server/src/message_processor.rs+++ b/codex-rs/app-server/src/message_processor.rs@@ -1318,6 +1318,9 @@ impl MessageProcessor {ClientRequest::ThreadMemoryModeSet { params, .. } => {self.thread_processor.thread_memory_mode_set(params).await}+ ClientRequest::MemoryStatus { params, .. } => {+ self.thread_processor.memory_status(params).await+ }ClientRequest::MemoryReset { .. } => self.thread_processor.memory_reset().await,ClientRequest::ThreadUnarchive { params, .. } => {self.thread_processordiff --git a/codex-rs/app-server/src/request_processors.rs b/codex-rs/app-server/src/request_processors.rsindex 4b22acac21..9795665a98 100644--- a/codex-rs/app-server/src/request_processors.rs+++ b/codex-rs/app-server/src/request_processors.rs@@ -552,6 +552,7 @@ mod initialize_processor;mod marketplace_processor;mod mcp_event_stream;mod mcp_processor;+mod memory_status;mod persisted_resume_settings;mod plugins;mod process_exec_processor;diff --git a/codex-rs/app-server/src/request_processors/memory_status.rs b/codex-rs/app-server/src/request_processors/memory_status.rsnew file mode 100644index 0000000000..b7847015dc--- /dev/null+++ b/codex-rs/app-server/src/request_processors/memory_status.rs@@ -0,0 +1,50 @@+//! Reports v2 readiness without exposing memory contents or persistence details to clients.++use super::*;+use codex_app_server_protocol::MemoryStatusParams;+use codex_app_server_protocol::MemoryStatusResponse;+use codex_protocol::MemoryVersion;++impl ThreadRequestProcessor {+ pub(crate) async fn memory_status(+ &self,+ params: MemoryStatusParams,+ ) -> Result<Option<ClientResponsePayload>, JSONRPCErrorError> {+ let minimum = params.min_consolidated_threads.unwrap_or(20);+ if !(1..=4096).contains(&minimum) {+ return Err(invalid_params(+ "minConsolidatedThreads must be between 1 and 4096",+ ));+ }+ let db = self+ .state_db+ .as_ref()+ .ok_or_else(|| internal_error("sqlite state db unavailable for memory status"))?;+ let store = db+ .memories_for_version(MemoryVersion::V2)+ .await+ .map_err(|error| internal_error(format!("failed to open v2 memory state: {error}")))?;+ let count = store+ .max_consolidated_thread_count()+ .await+ .map_err(|error| internal_error(format!("failed to read memory progress: {error}")))?;+ let root = self+ .config+ .codex_home+ .join(MemoryVersion::V2.directory_name());+ let summary = tokio::fs::read_to_string(root.join("memory_summary.md"))+ .await+ .ok();+ let ready = count >= minimum+ && summary+ .as_deref()+ .is_some_and(codex_memories_write::workspace::is_valid_v2_summary);+ Ok(Some(+ MemoryStatusResponse {+ v2_consolidated_threads: count,+ v2_ready: ready,+ }+ .into(),+ ))+ }+}diff --git a/codex-rs/app-server/tests/suite/v2/memory_reset.rs b/codex-rs/app-server/tests/suite/v2/memory_reset.rsindex d0274bb88d..1effa23de5 100644--- a/codex-rs/app-server/tests/suite/v2/memory_reset.rs+++ b/codex-rs/app-server/tests/suite/v2/memory_reset.rs@@ -145,3 +145,112 @@ async fn init_state_db(codex_home: &Path) -> Result<Arc<StateRuntime>> {.await?;Ok(state_db)}++#[tokio::test]+async fn memory_status_requires_successful_v2_consolidation_and_resets() -> Result<()> {+ use codex_app_server_protocol::MemoryStatusResponse;+ use codex_state::Phase2JobClaimOutcome;+ let home = TempDir::new()?;+ MockResponsesConfig::new("http://127.0.0.1:9")+ .enable_feature(Feature::Sqlite)+ .write(home.path())?;+ let db = init_state_db(home.path()).await?;+ seed_stage1_output(&db, home.path(), MemoryVersion::V1).await?;+ let source = seed_stage1_output(&db, home.path(), MemoryVersion::V2).await?;+ seed_stage1_output(&db, home.path(), MemoryVersion::V2).await?;+ let mut server = TestAppServer::builder()+ .with_codex_home(home.path())+ .without_auto_env()+ .build_initialized_with_timeout(DEFAULT_READ_TIMEOUT)+ .await?;+ let params = serde_json::json!({"minConsolidatedThreads": 2});+ let request = server+ .send_raw_request("memory/status", Some(params.clone()))+ .await?;+ let status: MemoryStatusResponse = server.read_response(request).await?;+ assert_eq!(+ status,+ MemoryStatusResponse {+ v2_consolidated_threads: 0,+ v2_ready: false+ }+ );++ let store = db.memories_for_version(MemoryVersion::V2).await?;+ let outputs = store.list_stage1_outputs_for_global(/*n*/ 20).await?;+ let Phase2JobClaimOutcome::Claimed {+ ownership_token,+ input_watermark,+ } = store+ .try_claim_global_phase2_job(source, /*lease_seconds*/ 60)+ .await?+ else {+ panic!("claim phase 2")+ };+ assert!(+ !store+ .mark_global_phase2_job_succeeded("wrong owner", input_watermark, &outputs)+ .await?+ );+ assert_eq!(store.max_consolidated_thread_count().await?, 0);+ assert!(+ store+ .mark_global_phase2_job_succeeded(&ownership_token, input_watermark, &outputs)+ .await?+ );+ // A completed job without a usable artifact must not activate v2.+ let request = server+ .send_raw_request("memory/status", Some(params.clone()))+ .await?;+ let status: MemoryStatusResponse = server.read_response(request).await?;+ assert_eq!(+ status,+ MemoryStatusResponse {+ v2_consolidated_threads: 2,+ v2_ready: false+ }+ );+ let root = home.path().join("memories_v2");+ tokio::fs::create_dir_all(&root).await?;+ tokio::fs::write(root.join("memory_summary.md"), "v1\n## User Profile\nTest user\n## User preferences\nTest preference\n## General Tips\nTest tip\n## What's in Memory\nTest source\n").await?;+ db.delete_thread(source).await?;+ let request = server+ .send_raw_request("memory/status", Some(params.clone()))+ .await?;+ let status: MemoryStatusResponse = server.read_response(request).await?;+ assert_eq!(+ status,+ MemoryStatusResponse {+ v2_consolidated_threads: 2,+ v2_ready: true+ }+ );+ // The default threshold remains 20 even though a caller can choose a smaller cohort.+ let request = server+ .send_raw_request("memory/status", Some(serde_json::json!({})))+ .await?;+ let status: MemoryStatusResponse = server.read_response(request).await?;+ assert_eq!(+ status,+ MemoryStatusResponse {+ v2_consolidated_threads: 2,+ v2_ready: false+ }+ );+ let request = server+ .send_raw_request("memory/reset", /*params*/ None)+ .await?;+ let _: MemoryResetResponse = server.read_response(request).await?;+ let request = server+ .send_raw_request("memory/status", Some(params))+ .await?;+ let status: MemoryStatusResponse = server.read_response(request).await?;+ assert_eq!(+ status,+ MemoryStatusResponse {+ v2_consolidated_threads: 0,+ v2_ready: false+ }+ );+ Ok(())+}diff --git a/codex-rs/config/src/types.rs b/codex-rs/config/src/types.rsindex 15f02473e5..abd8ee058f 100644--- a/codex-rs/config/src/types.rs+++ b/codex-rs/config/src/types.rs@@ -294,6 +294,8 @@ 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.+ 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")]pub disable_on_external_context: Option<bool>,@@ -328,6 +330,7 @@ pub struct MemoriesToml {#[derive(Debug, Clone, PartialEq, Eq, Serialize)]pub struct MemoriesConfig {pub version: MemoryVersion,+ pub dual_write: bool,pub disable_on_external_context: bool,pub generate_memories: bool,pub use_memories: bool,@@ -346,6 +349,7 @@ impl Default for MemoriesConfig {fn default() -> Self {Self {version: MemoryVersion::V1,+ dual_write: false,disable_on_external_context: false,generate_memories: true,use_memories: true,@@ -367,6 +371,7 @@ impl From<MemoriesToml> for MemoriesConfig {let defaults = Self::default();Self {version: toml.version.unwrap_or(defaults.version),+ dual_write: toml.dual_write.unwrap_or(defaults.dual_write),disable_on_external_context: toml.disable_on_external_context.unwrap_or(defaults.disable_on_external_context),diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex 02688af380..024ebbc285 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -2081,6 +2081,10 @@"description": "When `true`, external context sources mark the thread `memory_mode` as `\"polluted\"`.","type": "boolean"},+ "dual_write": {+ "description": "Generate both versions while the selected version supplies context.",+ "type": "boolean"+ },"extract_model": {"description": "Model used for thread summarisation.","type": "string"diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rsindex 50bea9b56b..35e496f3cf 100644--- a/codex-rs/core/src/config/config_tests.rs+++ b/codex-rs/core/src/config/config_tests.rs@@ -334,6 +334,7 @@ consolidation_model = "gpt-5.2"toml::from_str::<ConfigToml>(memories).expect("TOML deserialization should succeed");assert_eq!(Some(MemoriesToml {+ dual_write: None,version: None,disable_on_external_context: Some(true),generate_memories: Some(false),@@ -361,6 +362,7 @@ consolidation_model = "gpt-5.2"assert_eq!(config.memories,MemoriesConfig {+ dual_write: false,version: codex_protocol::MemoryVersion::V1,disable_on_external_context: true,generate_memories: false,diff --git a/codex-rs/memories/write/src/runtime.rs b/codex-rs/memories/write/src/runtime.rsindex d35c5fbc78..cbd4a06978 100644--- a/codex-rs/memories/write/src/runtime.rs+++ b/codex-rs/memories/write/src/runtime.rs@@ -47,6 +47,7 @@ pub(crate) struct SpawnedConsolidationAgent {#[derive(Clone, Debug)]pub(crate) struct StageOneRequestContext {+ version: MemoryVersion,pub(crate) model_info: ModelInfo,pub(crate) session_telemetry: SessionTelemetry,pub(crate) reasoning_effort: Option<ReasoningEffort>,@@ -56,15 +57,19 @@ pub(crate) struct StageOneRequestContext {impl StageOneRequestContext {pub(crate) fn start_timer(&self, name: &str) -> Option<codex_otel::Timer> {- self.session_telemetry.start_timer(name, &[]).ok()+ self.session_telemetry+ .start_timer(name, &memory_metric_tags(self.version, &[]))+ .ok()}pub(crate) fn counter(&self, name: &str, inc: i64, tags: &[(&str, &str)]) {- self.session_telemetry.counter(name, inc, tags);+ self.session_telemetry+ .counter(name, inc, &memory_metric_tags(self.version, tags));}pub(crate) fn histogram(&self, name: &str, value: i64, tags: &[(&str, &str)]) {- self.session_telemetry.histogram(name, value, tags);+ self.session_telemetry+ .histogram(name, value, &memory_metric_tags(self.version, tags));}}@@ -78,6 +83,21 @@ pub(crate) struct MemoryStartupContext {session_telemetry: SessionTelemetry,}+fn memory_metric_tags<'a>(+ version: MemoryVersion,+ tags: &[(&'a str, &'a str)],+) -> Vec<(&'a str, &'a str)> {+ let mut tags = tags.to_vec();+ tags.push((+ "memory_version",+ match version {+ MemoryVersion::V1 => "v1",+ MemoryVersion::V2 => "v2",+ },+ ));+ tags+}+fn build_session_telemetry(auth_manager: &AuthManager,thread_id: ThreadId,@@ -209,15 +229,19 @@ impl MemoryStartupContext {}pub(crate) fn counter(&self, name: &str, inc: i64, tags: &[(&str, &str)]) {- self.session_telemetry.counter(name, inc, tags);+ self.session_telemetry+ .counter(name, inc, &memory_metric_tags(self.version, tags));}pub(crate) fn histogram(&self, name: &str, value: i64, tags: &[(&str, &str)]) {- self.session_telemetry.histogram(name, value, tags);+ self.session_telemetry+ .histogram(name, value, &memory_metric_tags(self.version, tags));}pub(crate) fn start_timer(&self, name: &str) -> Option<codex_otel::Timer> {- self.session_telemetry.start_timer(name, &[]).ok()+ self.session_telemetry+ .start_timer(name, &memory_metric_tags(self.version, &[]))+ .ok()}pub(crate) async fn stage_one_request_context(@@ -237,6 +261,7 @@ impl MemoryStartupContext {.unwrap_or(model_info.default_reasoning_summary);StageOneRequestContext {+ version: self.version,model_info,session_telemetry: build_session_telemetry(&self.auth_manager,diff --git a/codex-rs/memories/write/src/start.rs b/codex-rs/memories/write/src/start.rsindex 8a766d86c0..ebd0b9950e 100644--- a/codex-rs/memories/write/src/start.rs+++ b/codex-rs/memories/write/src/start.rs@@ -10,6 +10,7 @@ use codex_core::ThreadManager;use codex_core::config::Config;use codex_features::Feature;use codex_login::AuthManager;+use codex_protocol::MemoryVersion;use codex_protocol::ThreadId;use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::SessionSource;@@ -36,47 +37,58 @@ pub fn start_memories_startup_task(return;}- let context = Arc::new(MemoryStartupContext::new(- thread_manager,- Arc::clone(&auth_manager),- thread_id,- thread,- config.as_ref(),- source.clone(),- ));+ let versions = if config.memories.dual_write {+ vec![MemoryVersion::V1, MemoryVersion::V2]+ } else {+ vec![config.memories.version]+ };+ for version in versions {+ let mut pipeline_config = config.as_ref().clone();+ pipeline_config.memories.version = version;+ let config = Arc::new(pipeline_config);+ let auth_manager = Arc::clone(&auth_manager);+ let parent_permission_profile = parent_permission_profile.clone();+ let context = Arc::new(MemoryStartupContext::new(+ Arc::clone(&thread_manager),+ Arc::clone(&auth_manager),+ thread_id,+ Arc::clone(&thread),+ config.as_ref(),+ source.clone(),+ ));+ tokio::spawn(async move {+ if context.memory_store().await.is_none() {+ warn!("state db unavailable for memories startup pipeline; skipping");+ return;+ }+ let root = config+ .codex_home+ .join(config.memories.version.directory_name());+ if let Err(err) = ensure_layout(&root).await {+ warn!("failed preparing memories root: {err}");+ return;+ }+ if let Err(err) = seed_extension_instructions(&root).await {+ warn!("failed seeding memory extension instructions: {err}");+ }- tokio::spawn(async move {- if context.memory_store().await.is_none() {- warn!("state db unavailable for memories startup pipeline; skipping");- return;- }- let root = config- .codex_home- .join(config.memories.version.directory_name());- if let Err(err) = ensure_layout(&root).await {- warn!("failed preparing memories root: {err}");- return;- }- if let Err(err) = seed_extension_instructions(&root).await {- warn!("failed seeding memory extension instructions: {err}");- }+ // Clean memories to make preserve DB size. This does not consume tokens so can be+ // done before the quota check.+ phase1::prune(context.as_ref(), &config).await;- // Clean memories to make preserve DB size. This does not consume tokens so can be- // done before the quota check.- phase1::prune(context.as_ref(), &config).await;+ if !guard::rate_limits_ok(&auth_manager, &config).await {+ context.counter(+ MEMORY_STARTUP,+ /*inc*/ 1,+ &[("status", "skipped_rate_limit")],+ );+ return;+ }- if !guard::rate_limits_ok(&auth_manager, &config).await {- context.counter(- MEMORY_STARTUP,- /*inc*/ 1,- &[("status", "skipped_rate_limit")],- );- return;- }-- // Run phase 1.- phase1::run(Arc::clone(&context), Arc::clone(&config)).await;- // Run phase 2.- phase2::run(context, config, parent_permission_profile).await;- });+ // Run phase 1.+ phase1::run(Arc::clone(&context), Arc::clone(&config)).await;+ // Run phase 2.+ phase2::run(context, config, parent_permission_profile).await;+ });+ }}diff --git a/codex-rs/memories/write/src/startup_dual_write_tests.rs b/codex-rs/memories/write/src/startup_dual_write_tests.rsnew file mode 100644index 0000000000..8d25d03977--- /dev/null+++ b/codex-rs/memories/write/src/startup_dual_write_tests.rs@@ -0,0 +1,110 @@+//! Exercises both startup pipelines through model requests and committed versioned state.++use super::*;+use codex_protocol::MemoryVersion;+use core_test_support::responses::sse_response;+use pretty_assertions::assert_eq;+use wiremock::Mock;+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;++ 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?;+ let deadline = Instant::now() + Duration::from_secs(10);+ 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)]+ );+ let summaries = read_rollout_summary_bodies(root).await?;+ assert_eq!(summaries.len(), 1);+ assert!(summaries[0].contains(expected_summary));+ }+ 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(())+}diff --git a/codex-rs/memories/write/src/startup_tests.rs b/codex-rs/memories/write/src/startup_tests.rsindex 9b44b0488d..6a93d6754a 100644--- a/codex-rs/memories/write/src/startup_tests.rs+++ b/codex-rs/memories/write/src/startup_tests.rs@@ -59,6 +59,9 @@ use tempfile::TempDir;use tokio::time::Duration;use tokio::time::Instant;+#[path = "startup_dual_write_tests.rs"]+mod dual_write;+#[tokio::test]async fn memories_startup_creates_memory_root() -> anyhow::Result<()> {let server = start_mock_server().await;@@ -74,6 +77,33 @@ async fn memories_startup_creates_memory_root() -> anyhow::Result<()> {Ok(())}+#[tokio::test]+async fn dual_write_prepares_both_roots_without_importing_old_notes() -> anyhow::Result<()> {+ let server = start_mock_server().await;+ let home = Arc::new(TempDir::new()?);+ let old_notes = home.path().join("memories/extensions/ad_hoc/notes");+ tokio::fs::create_dir_all(&old_notes).await?;+ tokio::fs::write(old_notes.join("old.md"), "old memory").await?;+ 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?;+ trigger_memories_startup(&test).await;+ wait_for_dir(&home.path().join("memories/extensions/ad_hoc")).await?;+ wait_for_dir(&home.path().join("memories_v2/extensions/ad_hoc")).await?;+ assert_eq!(+ tokio::fs::read_to_string(old_notes.join("old.md")).await?,+ "old memory"+ );+ assert!(+ !home+ .path()+ .join("memories_v2/extensions/ad_hoc/notes/old.md")+ .exists()+ );+ shutdown_test_codex(&test).await?;+ Ok(())+}+#[cfg(unix)]#[tokio::test]async fn memories_startup_removes_symlinked_extensions_before_seeding() -> anyhow::Result<()> {diff --git a/codex-rs/memories/write/src/workspace.rs b/codex-rs/memories/write/src/workspace.rsindex a796e093c4..e7081fa351 100644--- a/codex-rs/memories/write/src/workspace.rs+++ b/codex-rs/memories/write/src/workspace.rs@@ -89,23 +89,23 @@ pub(crate) async fn validate_consolidation_artifacts_for_version();if version == MemoryVersion::V2 {- for heading in [+ anyhow::ensure!(is_valid_v2_summary(&summary), "invalid v2 memory summary");+ }+ Ok(())+}++/// Checks the artifact shared by the writer and the read-only readiness endpoint.+pub fn is_valid_v2_summary(summary: &str) -> bool {+ summary.lines().next() == Some("v1")+ && summary.len() < 10_000+ && ["## User Profile","## User preferences","## General Tips","## What's in Memory",- ] {- anyhow::ensure!(- summary.lines().any(|line| line.trim() == heading),- "v2 memory summary missing {heading}"- );- }- anyhow::ensure!(- summary.len() < 10_000,- "v2 memory summary must be under 10000 UTF-8 bytes"- );- }- Ok(())+ ]+ .iter()+ .all(|heading| summary.lines().any(|line| line.trim() == *heading))}pub(crate) async fn remove_memory_symlinks(root: &Path) -> std::io::Result<usize> {diff --git a/codex-rs/state/memory_migrations/0002_consolidation_progress.sql b/codex-rs/state/memory_migrations/0002_consolidation_progress.sqlnew file mode 100644index 0000000000..ec84e3a127--- /dev/null+++ b/codex-rs/state/memory_migrations/0002_consolidation_progress.sql@@ -0,0 +1,6 @@+-- A successful consolidation is the readiness boundary for the version experiment.+CREATE TABLE consolidation_progress (+ singleton INTEGER PRIMARY KEY CHECK (singleton = 1),+ max_thread_count INTEGER NOT NULL DEFAULT 0+);+INSERT INTO consolidation_progress (singleton) VALUES (1);diff --git a/codex-rs/state/src/runtime/memories.rs b/codex-rs/state/src/runtime/memories.rsindex b282db92f3..6eb810bc46 100644--- a/codex-rs/state/src/runtime/memories.rs+++ b/codex-rs/state/src/runtime/memories.rs@@ -1,3 +1,6 @@+#[path = "memory_readiness.rs"]+mod readiness;+use super::threads::ThreadFilterOptions;use super::threads::push_thread_filters;use super::*;@@ -1295,6 +1298,12 @@ WHERE thread_id = ? AND source_updated_at = ?.await?;}+ sqlx::query(+ "UPDATE consolidation_progress SET max_thread_count = MAX(max_thread_count, ?)",+ )+ .bind(i64::try_from(selected_outputs.len())?)+ .execute(&mut *tx)+ .await?;tx.commit().await?;Ok(true)}@@ -1420,6 +1429,9 @@ WHERE kind = ? AND job_key = ?pub(super) async fn clear_memory_data_in_pool(pool: &SqlitePool) -> anyhow::Result<()> {let mut tx = pool.begin().await?;+ sqlx::query("UPDATE consolidation_progress SET max_thread_count = 0")+ .execute(&mut *tx)+ .await?;sqlx::query(r#"diff --git a/codex-rs/state/src/runtime/memory_readiness.rs b/codex-rs/state/src/runtime/memory_readiness.rsnew file mode 100644index 0000000000..7a9f1db7a3--- /dev/null+++ b/codex-rs/state/src/runtime/memory_readiness.rs@@ -0,0 +1,16 @@+//! Consolidation progress used to select a warmed memory pipeline.++use super::MemoryStore;++impl MemoryStore {+ /// Largest number of distinct source threads included in a successful consolidation.+ /// Kept across ordinary pruning, and cleared by an explicit memory reset.+ pub async fn max_consolidated_thread_count(&self) -> anyhow::Result<u32> {+ let count: i64 = sqlx::query_scalar(+ "SELECT max_thread_count FROM consolidation_progress WHERE singleton = 1",+ )+ .fetch_one(self.pool.as_ref())+ .await?;+ Ok(u32::try_from(count)?)+ }+}