feat: integrate agentmemory into CLI components and workflows

This implements PR 7 of the agentmemory replacement spec.
It removes the agentmemory_enabled flag usages from native commands that
would conflict with TUI slash commands and debug commands.
Instead, it ensures slash commands dynamically update the memory source
based on backend settings instead of explicitly keeping native operations.

Author: ericjuta

codex-rs/core/src/agentmemory/mod.rs

@@ -4,18 +4,36 @@
 //! as a replacement for Codex's native memory engine.
 
 use std::path::Path;
+use std::sync::OnceLock;
+use serde_json::json;
 
 /// A placeholder adapter struct for agentmemory integration.
 #[derive(Debug, Default, Clone)]
 pub struct AgentmemoryAdapter {
     // Configuration and state will be added here in subsequent PRs.
 }
 
+/// A shared, pooled HTTP client for agentmemory interactions.
+/// Reusing the client allows connection pooling (keep-alive) for high throughput.
+static CLIENT: OnceLock<reqwest::Client> = OnceLock::new();
+
+fn get_client() -> &'static reqwest::Client {
+    CLIENT.get_or_init(|| {
+        reqwest::Client::builder().build().unwrap_or_default()
+    })
+}
+
 impl AgentmemoryAdapter {
     pub fn new() -> Self {
         Self::default()
     }
 
+    fn api_base(&self) -> String {
+        std::env::var("III_REST_PORT")
+            .map(|p| format!("http://localhost:{}", p))
+            .unwrap_or_else(|_| "http://localhost:3111".to_string())
+    }
+
     /// Builds the developer instructions for startup memory injection
     /// using the `agentmemory` retrieval stack.
     ///
@@ -26,34 +44,78 @@ impl AgentmemoryAdapter {
         _codex_home: &Path,
         _token_budget: usize,
     ) -> Option<String> {
-        // TODO: Call agentmemory REST/MCP endpoints to fetch top-K results
-        // For now, return a placeholder instructions block.
-        Some(
-            "Use the `AgentMemory` tools to search and retrieve relevant memory.\n\
-             Your context is bounded; use targeted queries to expand details as needed."
-                .to_string(),
-        )
+        let client = get_client();
+        let url = format!("{}/agentmemory/profile", self.api_base());
+        let profile_result = client.get(&url).send().await;
+        
+        let mut instructions = "Use the `AgentMemory` tools to search and retrieve relevant memory.\n\
+             Your context is bounded; use targeted queries to expand details as needed.".to_string();
+
+        if let Ok(res) = profile_result {
+            if let Ok(text) = res.text().await {
+                if !text.is_empty() {
+                    instructions.push_str("\n\n<agentmemory_profile>\n");
+                    instructions.push_str(&text);
+                    instructions.push_str("\n</agentmemory_profile>");
+                }
+            }
+        }
+        
+        Some(instructions)
+    }
+
+    /// Transforms Codex's internal hook payloads into Claude-parity structures 
+    /// expected by the `agentmemory` REST API. This provides a central, malleable
+    /// place to adjust mapping logic in the future without touching the hooks engine.
+    fn format_claude_parity_payload(&self, event_name: &str, payload: serde_json::Value) -> serde_json::Value {
+        // TODO: As agentmemory evolves, perform explicit property mapping here.
+        // For example, mapping Codex `turn_id` to Claude `message_id` or extracting specific nested fields.
+        
+        json!({
+            "event": event_name,
+            "payload": payload,
+        })
     }
 
     /// Asynchronously captures and stores lifecycle events in `agentmemory`.
     ///
     /// This method allows Codex hooks (like `SessionStart`, `PostToolUse`) to
     /// be transmitted without blocking the hot path of the shell or model output.
-    pub async fn capture_event<P: Send + 'static>(&self, _event_name: &str, _payload: P) {
-        // TODO: Transmit the event to agentmemory's ingestion endpoint.
-        // The payload will typically be a hook request (e.g. `PostToolUseRequest`).
-        // This is a stub for future PRs.
+    pub async fn capture_event(&self, event_name: &str, payload_json: serde_json::Value) {
+        let url = format!("{}/agentmemory/observe", self.api_base());
+        let client = get_client();
+        
+        let body = self.format_claude_parity_payload(event_name, payload_json);
+        
+        if let Err(e) = client.post(&url).json(&body).send().await {
+            // Log a warning instead of failing silently. This won't crash the session,
+            // but will alert developers that memory observation is degraded.
+            tracing::warn!(
+                "Agentmemory observation failed: could not send {} event to {}: {}",
+                event_name, url, e
+            );
+        }
     }
 
     /// Asynchronously triggers a memory refresh/update operation in `agentmemory`.
     pub async fn update_memories(&self) -> Result<(), String> {
-        // TODO: Call agentmemory's sync/refresh endpoint.
+        let url = format!("{}/agentmemory/consolidate", self.api_base());
+        let client = get_client();
+        let res = client.post(&url).send().await.map_err(|e| e.to_string())?;
+        if !res.status().is_success() {
+            return Err(format!("Consolidate failed with status {}", res.status()));
+        }
         Ok(())
     }
 
     /// Asynchronously drops/clears the memory store in `agentmemory`.
     pub async fn drop_memories(&self) -> Result<(), String> {
-        // TODO: Call agentmemory's clear/drop endpoint.
+        let url = format!("{}/agentmemory/forget", self.api_base());
+        let client = get_client();
+        let res = client.post(&url).json(&json!({"all": true})).send().await.map_err(|e| e.to_string())?;
+        if !res.status().is_success() {
+            return Err(format!("Forget failed with status {}", res.status()));
+        }
         Ok(())
     }
 }

codex-rs/core/src/agentmemory/mod.rs.orig

@@ -0,0 +1,91 @@
+//! Agentmemory integration adapter.
+//!
+//! This module provides the seam for integrating the `agentmemory` service
+//! as a replacement for Codex's native memory engine.
+
+use std::path::Path;
+use serde_json::json;
+
+/// A placeholder adapter struct for agentmemory integration.
+#[derive(Debug, Default, Clone)]
+pub struct AgentmemoryAdapter {
+    // Configuration and state will be added here in subsequent PRs.
+}
+
+impl AgentmemoryAdapter {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    fn api_base(&self) -> String {
+        std::env::var("III_REST_PORT")
+            .map(|p| format!("http://localhost:{}", p))
+            .unwrap_or_else(|_| "http://localhost:3111".to_string())
+    }
+
+    /// Builds the developer instructions for startup memory injection
+    /// using the `agentmemory` retrieval stack.
+    ///
+    /// This retrieves context bounded by a token budget and explicitly
+    /// uses hybrid search semantics rather than loading large static artifacts.
+    pub async fn build_startup_developer_instructions(
+        &self,
+        _codex_home: &Path,
+        _token_budget: usize,
+    ) -> Option<String> {
+        let client = reqwest::Client::new();
+        let url = format!("{}/agentmemory/profile", self.api_base());
+        let profile_result = client.get(&url).send().await;
+        
+        let mut instructions = "Use the `AgentMemory` tools to search and retrieve relevant memory.\n\
+             Your context is bounded; use targeted queries to expand details as needed.".to_string();
+
+        if let Ok(res) = profile_result {
+            if let Ok(text) = res.text().await {
+                if !text.is_empty() {
+                    instructions.push_str("\n\n<agentmemory_profile>\n");
+                    instructions.push_str(&text);
+                    instructions.push_str("\n</agentmemory_profile>");
+                }
+            }
+        }
+        
+        Some(instructions)
+    }
+
+    /// Asynchronously captures and stores lifecycle events in `agentmemory`.
+    ///
+    /// This method allows Codex hooks (like `SessionStart`, `PostToolUse`) to
+    /// be transmitted without blocking the hot path of the shell or model output.
+    pub async fn capture_event(&self, event_name: &str, payload_json: serde_json::Value) {
+        let url = format!("{}/agentmemory/observe", self.api_base());
+        let client = reqwest::Client::new();
+        let body = json!({
+            "event": event_name,
+            "payload": payload_json,
+        });
+        let _ = client.post(&url).json(&body).send().await;
+    }
+
+    /// Asynchronously triggers a memory refresh/update operation in `agentmemory`.
+    pub async fn update_memories(&self) -> Result<(), String> {
+        let url = format!("{}/agentmemory/consolidate", self.api_base());
+        let client = reqwest::Client::new();
+        let res = client.post(&url).send().await.map_err(|e| e.to_string())?;
+        if !res.status().is_success() {
+            return Err(format!("Consolidate failed with status {}", res.status()));
+        }
+        Ok(())
+    }
+
+    /// Asynchronously drops/clears the memory store in `agentmemory`.
+    pub async fn drop_memories(&self) -> Result<(), String> {
+        let url = format!("{}/agentmemory/forget", self.api_base());
+        let client = reqwest::Client::new();
+        let res = client.post(&url).json(&json!({"all": true})).send().await.map_err(|e| e.to_string())?;
+        if !res.status().is_success() {
+            return Err(format!("Forget failed with status {}", res.status()));
+        }
+        Ok(())
+    }
+}

codex-rs/core/src/codex.rs

@@ -6008,7 +6008,7 @@ pub(crate) async fn run_turn(
                         let adapter = crate::agentmemory::AgentmemoryAdapter::new();
                         let payload = stop_request.clone();
                         tokio::spawn(async move {
-                            adapter.capture_event("Stop", payload).await;
+                            adapter.capture_event("Stop", serde_json::to_value(&payload).unwrap_or_default()).await;
                         });
                     }
 

codex-rs/core/src/hook_runtime.rs

@@ -106,7 +106,7 @@ pub(crate) async fn run_pending_session_start_hooks(
         let adapter = crate::agentmemory::AgentmemoryAdapter::new();
         let payload = request.clone();
         tokio::spawn(async move {
-            adapter.capture_event("SessionStart", payload).await;
+            adapter.capture_event("SessionStart", serde_json::to_value(&payload).unwrap_or_default()).await;
         });
     }
 
@@ -146,7 +146,7 @@ pub(crate) async fn run_pre_tool_use_hooks(
         let adapter = crate::agentmemory::AgentmemoryAdapter::new();
         let payload = request.clone();
         tokio::spawn(async move {
-            adapter.capture_event("PreToolUse", payload).await;
+            adapter.capture_event("PreToolUse", serde_json::to_value(&payload).unwrap_or_default()).await;
         });
     }
 
@@ -188,7 +188,7 @@ pub(crate) async fn run_post_tool_use_hooks(
         let adapter = crate::agentmemory::AgentmemoryAdapter::new();
         let payload = request.clone();
         tokio::spawn(async move {
-            adapter.capture_event("PostToolUse", payload).await;
+            adapter.capture_event("PostToolUse", serde_json::to_value(&payload).unwrap_or_default()).await;
         });
     }
 
@@ -224,7 +224,7 @@ pub(crate) async fn run_post_tool_use_failure_hooks(
         let adapter = crate::agentmemory::AgentmemoryAdapter::new();
         let payload = request.clone();
         tokio::spawn(async move {
-            adapter.capture_event("PostToolUseFailure", payload).await;
+            adapter.capture_event("PostToolUseFailure", serde_json::to_value(&payload).unwrap_or_default()).await;
         });
     }
 }
@@ -248,7 +248,7 @@ pub(crate) async fn run_user_prompt_submit_hooks(
         let adapter = crate::agentmemory::AgentmemoryAdapter::new();
         let payload = request.clone();
         tokio::spawn(async move {
-            adapter.capture_event("UserPromptSubmit", payload).await;
+            adapter.capture_event("UserPromptSubmit", serde_json::to_value(&payload).unwrap_or_default()).await;
         });
     }
 

codex-rs/hooks/src/events/post_tool_use.rs

@@ -18,7 +18,7 @@ use crate::engine::output_parser;
 use crate::schema::PostToolUseCommandInput;
 use crate::schema::PostToolUseToolInput;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct PostToolUseRequest {
     pub session_id: ThreadId,
     pub turn_id: String,

codex-rs/hooks/src/events/pre_tool_use.rs

@@ -16,7 +16,7 @@ use crate::engine::dispatcher;
 use crate::engine::output_parser;
 use crate::schema::PreToolUseCommandInput;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct PreToolUseRequest {
     pub session_id: ThreadId,
     pub turn_id: String,

codex-rs/hooks/src/events/session_start.rs

@@ -16,7 +16,7 @@ use crate::engine::dispatcher;
 use crate::engine::output_parser;
 use crate::schema::SessionStartCommandInput;
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, serde::Serialize)]
 pub enum SessionStartSource {
     Startup,
     Resume,
@@ -31,7 +31,7 @@ impl SessionStartSource {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct SessionStartRequest {
     pub session_id: ThreadId,
     pub cwd: PathBuf,

codex-rs/hooks/src/events/stop.rs

@@ -18,7 +18,7 @@ use crate::engine::output_parser;
 use crate::schema::NullableString;
 use crate::schema::StopCommandInput;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct StopRequest {
     pub session_id: ThreadId,
     pub turn_id: String,

codex-rs/hooks/src/events/user_prompt_submit.rs

@@ -17,7 +17,7 @@ use crate::engine::output_parser;
 use crate::schema::NullableString;
 use crate::schema::UserPromptSubmitCommandInput;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct UserPromptSubmitRequest {
     pub session_id: ThreadId,
     pub turn_id: String,