memories: add extraction and prompt module foundation (#11200)

## Summary
- add the new `core/src/memories` module (phase-one parsing, rollout
filtering, storage, selection, prompts)
- add Askama-backed memory templates for stage-one input/system and
consolidation prompts
- add module tests for parsing, filtering, path bucketing, and summary
maintenance

## Testing
- just fmt
- cargo test -p codex-core --lib memories::

codex-rs/codex-api/README.md

@@ -29,13 +29,13 @@ The public interface of this crate is intentionally small and uniform:
   - Output: `Vec<ResponseItem>`.
   - `CompactClient::compact_input(&CompactionInput, extra_headers)` wraps the JSON encoding and retry/telemetry wiring.
 
-- **Memory trace summarize endpoint**
-  - Input: `MemoryTraceSummarizeInput` (re-exported as `codex_api::MemoryTraceSummarizeInput`):
+- **Memory summarize endpoint**
+  - Input: `MemorySummarizeInput` (re-exported as `codex_api::MemorySummarizeInput`):
     - `model: String`.
-    - `traces: Vec<MemoryTrace>`.
-      - `MemoryTrace` includes `id`, `metadata.source_path`, and normalized `items`.
+    - `raw_memories: Vec<RawMemory>` (serialized as `traces` for wire compatibility).
+      - `RawMemory` includes `id`, `metadata.source_path`, and normalized `items`.
     - `reasoning: Option<Reasoning>`.
-  - Output: `Vec<MemoryTraceSummaryOutput>`.
-  - `MemoriesClient::trace_summarize_input(&MemoryTraceSummarizeInput, extra_headers)` wraps JSON encoding and retry/telemetry wiring.
+  - Output: `Vec<MemorySummarizeOutput>`.
+  - `MemoriesClient::summarize_input(&MemorySummarizeInput, extra_headers)` wraps JSON encoding and retry/telemetry wiring.
 
 All HTTP details (URLs, headers, retry/backoff policies, SSE framing) are encapsulated in `codex-api` and `codex-client`. Callers construct prompts/inputs using protocol types and work with typed streams of `ResponseEvent` or compacted `ResponseItem` values.

codex-rs/codex-api/src/common.rs

@@ -38,30 +38,32 @@ pub struct CompactionInput<'a> {
     pub instructions: &'a str,
 }
 
-/// Canonical input payload for the memory trace summarize endpoint.
+/// Canonical input payload for the memory summarize endpoint.
 #[derive(Debug, Clone, Serialize)]
-pub struct MemoryTraceSummarizeInput {
+pub struct MemorySummarizeInput {
     pub model: String,
-    pub traces: Vec<MemoryTrace>,
+    #[serde(rename = "traces")]
+    pub raw_memories: Vec<RawMemory>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub reasoning: Option<Reasoning>,
 }
 
 #[derive(Debug, Clone, Serialize)]
-pub struct MemoryTrace {
+pub struct RawMemory {
     pub id: String,
-    pub metadata: MemoryTraceMetadata,
+    pub metadata: RawMemoryMetadata,
     pub items: Vec<Value>,
 }
 
 #[derive(Debug, Clone, Serialize)]
-pub struct MemoryTraceMetadata {
+pub struct RawMemoryMetadata {
     pub source_path: String,
 }
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
-pub struct MemoryTraceSummaryOutput {
-    pub trace_summary: String,
+pub struct MemorySummarizeOutput {
+    #[serde(rename = "trace_summary", alias = "raw_memory")]
+    pub raw_memory: String,
     pub memory_summary: String,
 }
 

codex-rs/codex-api/src/endpoint/memories.rs

@@ -1,6 +1,6 @@
 use crate::auth::AuthProvider;
-use crate::common::MemoryTraceSummarizeInput;
-use crate::common::MemoryTraceSummaryOutput;
+use crate::common::MemorySummarizeInput;
+use crate::common::MemorySummarizeOutput;
 use crate::endpoint::session::EndpointSession;
 use crate::error::ApiError;
 use crate::provider::Provider;
@@ -33,37 +33,35 @@ impl<T: HttpTransport, A: AuthProvider> MemoriesClient<T, A> {
         "memories/trace_summarize"
     }
 
-    pub async fn trace_summarize(
+    pub async fn summarize(
         &self,
         body: serde_json::Value,
         extra_headers: HeaderMap,
-    ) -> Result<Vec<MemoryTraceSummaryOutput>, ApiError> {
+    ) -> Result<Vec<MemorySummarizeOutput>, ApiError> {
         let resp = self
             .session
             .execute(Method::POST, Self::path(), extra_headers, Some(body))
             .await?;
-        let parsed: TraceSummarizeResponse =
+        let parsed: SummarizeResponse =
             serde_json::from_slice(&resp.body).map_err(|e| ApiError::Stream(e.to_string()))?;
         Ok(parsed.output)
     }
 
-    pub async fn trace_summarize_input(
+    pub async fn summarize_input(
         &self,
-        input: &MemoryTraceSummarizeInput,
+        input: &MemorySummarizeInput,
         extra_headers: HeaderMap,
-    ) -> Result<Vec<MemoryTraceSummaryOutput>, ApiError> {
+    ) -> Result<Vec<MemorySummarizeOutput>, ApiError> {
         let body = to_value(input).map_err(|e| {
-            ApiError::Stream(format!(
-                "failed to encode memory trace summarize input: {e}"
-            ))
+            ApiError::Stream(format!("failed to encode memory summarize input: {e}"))
         })?;
-        self.trace_summarize(body, extra_headers).await
+        self.summarize(body, extra_headers).await
     }
 }
 
 #[derive(Debug, Deserialize)]
-struct TraceSummarizeResponse {
-    output: Vec<MemoryTraceSummaryOutput>,
+struct SummarizeResponse {
+    output: Vec<MemorySummarizeOutput>,
 }
 
 #[cfg(test)]
@@ -99,7 +97,7 @@ mod tests {
     }
 
     #[test]
-    fn path_is_memories_trace_summarize() {
+    fn path_is_memories_trace_summarize_for_wire_compatibility() {
         assert_eq!(
             MemoriesClient::<DummyTransport, DummyAuth>::path(),
             "memories/trace_summarize"

codex-rs/codex-api/src/lib.rs

@@ -15,11 +15,11 @@ pub use codex_client::TransportError;
 
 pub use crate::auth::AuthProvider;
 pub use crate::common::CompactionInput;
-pub use crate::common::MemoryTrace;
-pub use crate::common::MemoryTraceMetadata;
-pub use crate::common::MemoryTraceSummarizeInput;
-pub use crate::common::MemoryTraceSummaryOutput;
+pub use crate::common::MemorySummarizeInput;
+pub use crate::common::MemorySummarizeOutput;
 pub use crate::common::Prompt;
+pub use crate::common::RawMemory;
+pub use crate::common::RawMemoryMetadata;
 pub use crate::common::ResponseAppendWsRequest;
 pub use crate::common::ResponseCreateWsRequest;
 pub use crate::common::ResponseEvent;