feat(server): refactor handlers, router, state management, and memory tools

server/src/handlers/ast.rs

@@ -4,7 +4,7 @@ use crate::tools::ReadFileSkeletonTool;
 use async_trait::async_trait;
 use serde_json::Value;
 use std::sync::Arc;
-use tree_sitter::{Parser, Node};
+use tree_sitter::{Node, Parser};
 
 pub struct ReadFileSkeletonHandler;
 
@@ -22,20 +22,22 @@ impl McpTool for ReadFileSkeletonHandler {
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: ReadFileSkeletonTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        
+        let tool_args: ReadFileSkeletonTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
+
         let file_path = tool_args.file_path.clone();
         let result = tokio::task::spawn_blocking(move || -> crate::error::Result<String> {
-            let code = std::fs::read_to_string(&file_path)
-                .map_err(|e| crate::error::AppError::Internal(format!("Failed to read file: {}", e)))?;
-                
+            let code = std::fs::read_to_string(&file_path).map_err(|e| {
+                crate::error::AppError::Internal(format!("Failed to read file: {}", e))
+            })?;
+
             let mut parser = Parser::new();
-            
+
             let ext = std::path::Path::new(&file_path)
                 .extension()
                 .and_then(|s| s.to_str())
                 .unwrap_or("");
-                
+
             let language = match ext {
                 "rs" => tree_sitter_rust::LANGUAGE,
                 "ts" | "tsx" | "js" | "jsx" => tree_sitter_typescript::LANGUAGE_TYPESCRIPT,
@@ -46,20 +48,41 @@ impl McpTool for ReadFileSkeletonHandler {
                 "go" => tree_sitter_go::LANGUAGE,
                 _ => return Ok(code),
             };
-            
-            parser.set_language(&language.into()).map_err(|e| e.to_string())?;
-            
-            let tree = parser.parse(&code, None).ok_or_else(|| crate::error::AppError::Internal("Failed to parse code".to_string()))?;
+
+            parser
+                .set_language(&language.into())
+                .map_err(|e| e.to_string())?;
+
+            let tree = parser.parse(&code, None).ok_or_else(|| {
+                crate::error::AppError::Internal("Failed to parse code".to_string())
+            })?;
             let mut result_skeleton = String::new();
-            
+
             fn extract_skeleton(node: Node, code: &str, out: &mut String, depth: usize) {
                 let kind = node.kind();
-                
-                let is_structural = matches!(kind, "use_declaration" | "import_statement" | "import_from_statement" | "struct_item" | "enum_item" | "trait_item" | "impl_item" | "function_item" | "function_declaration" | "function_definition" | "method_definition" | "interface_declaration" | "type_alias_declaration" | "class_declaration" | "class_definition");
+
+                let is_structural = matches!(
+                    kind,
+                    "use_declaration"
+                        | "import_statement"
+                        | "import_from_statement"
+                        | "struct_item"
+                        | "enum_item"
+                        | "trait_item"
+                        | "impl_item"
+                        | "function_item"
+                        | "function_declaration"
+                        | "function_definition"
+                        | "method_definition"
+                        | "interface_declaration"
+                        | "type_alias_declaration"
+                        | "class_declaration"
+                        | "class_definition"
+                );
 
                 if is_structural {
                     let indent = "  ".repeat(depth);
-                    
+
                     let node_text = node.utf8_text(code.as_bytes()).unwrap_or("");
                     let mut signature = String::new();
                     for line in node_text.lines() {
@@ -76,7 +99,7 @@ impl McpTool for ReadFileSkeletonHandler {
                     if signature.is_empty() {
                         signature = node_text.to_string();
                     }
-                    
+
                     out.push_str(&indent);
                     out.push_str(signature.trim());
                     out.push('\n');
@@ -87,9 +110,9 @@ impl McpTool for ReadFileSkeletonHandler {
                     }
                 }
             }
-            
+
             extract_skeleton(tree.root_node(), &code, &mut result_skeleton, 0);
-            
+
             if result_skeleton.is_empty() {
                 Ok(code)
             } else {
@@ -120,20 +143,22 @@ impl McpTool for ReplaceAstNodeHandler {
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: ReplaceAstNodeTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        
+        let tool_args: ReplaceAstNodeTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
+
         let file_path = tool_args.file_path.clone();
         let result = tokio::task::spawn_blocking(move || -> crate::error::Result<String> {
-            let code = std::fs::read_to_string(&file_path)
-                .map_err(|e| crate::error::AppError::Internal(format!("Failed to read file: {}", e)))?;
-                
+            let code = std::fs::read_to_string(&file_path).map_err(|e| {
+                crate::error::AppError::Internal(format!("Failed to read file: {}", e))
+            })?;
+
             let mut parser = Parser::new();
-            
+
             let ext = std::path::Path::new(&file_path)
                 .extension()
                 .and_then(|s| s.to_str())
                 .unwrap_or("");
-                
+
             let language = match ext {
                 "rs" => tree_sitter_rust::LANGUAGE,
                 "ts" | "tsx" | "js" | "jsx" => tree_sitter_typescript::LANGUAGE_TYPESCRIPT,
@@ -142,14 +167,28 @@ impl McpTool for ReplaceAstNodeHandler {
                 "c" | "h" => tree_sitter_c::LANGUAGE,
                 "cpp" | "cc" | "cxx" | "hpp" | "hxx" => tree_sitter_cpp::LANGUAGE,
                 "go" => tree_sitter_go::LANGUAGE,
-                _ => return Err(crate::error::AppError::Internal(format!("Unsupported language for AST replacement: {}", ext))),
+                _ => {
+                    return Err(crate::error::AppError::Internal(format!(
+                        "Unsupported language for AST replacement: {}",
+                        ext
+                    )));
+                }
             };
-            
-            parser.set_language(&language.into()).map_err(|e| e.to_string())?;
-            let tree = parser.parse(&code, None).ok_or_else(|| crate::error::AppError::Internal("Failed to parse code".to_string()))?;
-            
+
+            parser
+                .set_language(&language.into())
+                .map_err(|e| e.to_string())?;
+            let tree = parser.parse(&code, None).ok_or_else(|| {
+                crate::error::AppError::Internal("Failed to parse code".to_string())
+            })?;
+
             // Search for the node
-            fn find_node<'a>(node: Node<'a>, code: &str, target_type: &str, target_name: &str) -> Option<Node<'a>> {
+            fn find_node<'a>(
+                node: Node<'a>,
+                code: &str,
+                target_type: &str,
+                target_name: &str,
+            ) -> Option<Node<'a>> {
                 if node.kind() == target_type {
                     // Try to find the name/identifier
                     let mut cursor = node.walk();
@@ -163,7 +202,7 @@ impl McpTool for ReplaceAstNodeHandler {
                         }
                     }
                 }
-                
+
                 let mut cursor = node.walk();
                 for child in node.children(&mut cursor) {
                     if let Some(found) = find_node(child, code, target_type, target_name) {
@@ -172,22 +211,33 @@ impl McpTool for ReplaceAstNodeHandler {
                 }
                 None
             }
-            
-            let target_node = find_node(tree.root_node(), &code, &tool_args.node_type, &tool_args.node_name);
-            
+
+            let target_node = find_node(
+                tree.root_node(),
+                &code,
+                &tool_args.node_type,
+                &tool_args.node_name,
+            );
+
             if let Some(node) = target_node {
                 let start_byte = node.start_byte();
                 let end_byte = node.end_byte();
-                
+
                 let mut new_file_content = String::new();
                 new_file_content.push_str(&code[..start_byte]);
                 new_file_content.push_str(&tool_args.new_content);
                 new_file_content.push_str(&code[end_byte..]);
-                
+
                 std::fs::write(&file_path, new_file_content).map_err(|e| e.to_string())?;
-                Ok(format!("Successfully replaced node {} of type {} in {}", tool_args.node_name, tool_args.node_type, file_path))
+                Ok(format!(
+                    "Successfully replaced node {} of type {} in {}",
+                    tool_args.node_name, tool_args.node_type, file_path
+                ))
             } else {
-                Err(crate::error::AppError::Internal(format!("Could not find node {} of type {}", tool_args.node_name, tool_args.node_type)))
+                Err(crate::error::AppError::Internal(format!(
+                    "Could not find node {} of type {}",
+                    tool_args.node_name, tool_args.node_type
+                )))
             }
         })
         .await
@@ -208,7 +258,7 @@ mod tests {
         let dir = tempdir().unwrap();
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
         let file_path = dir.path().join("test_skeleton.rs");
-        
+
         let code = "fn my_func() {\n    let x = 1;\n}\n\nstruct MyStruct {\n    val: i32\n}";
         std::fs::write(&file_path, code).unwrap();
 
@@ -227,7 +277,7 @@ mod tests {
         let dir = tempdir().unwrap();
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
         let file_path = dir.path().join("test_replace.rs");
-        
+
         let code = "fn my_func() {\n    let x = 1;\n}\n\nstruct MyStruct {\n    val: i32\n}";
         std::fs::write(&file_path, code).unwrap();
 

server/src/handlers/env.rs

@@ -58,7 +58,8 @@ impl McpTool for ReadEnvFingerprintHandler {
         let req: ReadEnvFingerprintTool =
             serde_json::from_value(args).map_err(|e| e.to_string())?;
         let data = state
-            .env.env_fingerprints
+            .env
+            .env_fingerprints
             .read_with(|fps| fps.get(&req.namespace).cloned());
         if let Some(fp) = data {
             let data = Ok::<String, crate::error::AppError>(serde_json::to_string(&fp)?)?;
@@ -180,13 +181,19 @@ mod tests {
             }
         });
 
-        let res = update_handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = update_handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res, "Env fingerprint updated");
 
         let read_handler = ReadEnvFingerprintHandler;
         let res2 = read_handler
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res2.contains("rustc"));
         assert!(res2.contains("1.70.0"));
     }
@@ -211,7 +218,9 @@ mod tests {
         let handler = GetEnvironmentDetailsHandler;
         let res = handler
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
 
         assert!(res.contains("global"));
     }
@@ -230,7 +239,11 @@ mod tests {
             "context": "For database access",
             "namespace": "global"
         });
-        let res1 = req_handler.execute(args_req, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res1 = req_handler
+            .execute(args_req, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res1, "Env requirement logged");
 
         let reg_handler = RegisterEnvironmentHandler;
@@ -241,13 +254,19 @@ mod tests {
             "requires_vpn": true,
             "namespace": "global"
         });
-        let res2 = reg_handler.execute(args_reg, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res2 = reg_handler
+            .execute(args_reg, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res2, "Environment registered");
 
         let get_handler = GetEnvironmentDetailsHandler;
         let res3 = get_handler
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res3.contains("prod.local"));
         assert!(!res3.is_empty());
     }

server/src/handlers/git.rs

@@ -2,9 +2,9 @@ use crate::router::McpTool;
 use crate::state::MemoryState;
 use crate::tools::GetActiveWorktreeContextTool;
 use async_trait::async_trait;
-use serde_json::{json, Value};
-use std::sync::Arc;
+use serde_json::{Value, json};
 use std::env;
+use std::sync::Arc;
 
 pub struct GetActiveWorktreeContextHandler;
 
@@ -21,56 +21,66 @@ impl McpTool for GetActiveWorktreeContextHandler {
         )
     }
 
-    async fn execute(&self, _args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let result = tokio::task::spawn_blocking(move || -> crate::error::Result<serde_json::Value> {
-            let cwd = env::current_dir().map_err(|e| e.to_string())?;
-            let repo = git2::Repository::discover(&cwd).map_err(|e| crate::error::AppError::Internal(format!("Not in a git repository: {}", e)))?;
-            
-            let mut branch_name = String::new();
-            if let Ok(head) = repo.head()
-                && let Some(name) = head.shorthand() {
+    async fn execute(
+        &self,
+        _args: Value,
+        _state: Arc<MemoryState>,
+    ) -> crate::error::Result<String> {
+        let result =
+            tokio::task::spawn_blocking(move || -> crate::error::Result<serde_json::Value> {
+                let cwd = env::current_dir().map_err(|e| e.to_string())?;
+                let repo = git2::Repository::discover(&cwd).map_err(|e| {
+                    crate::error::AppError::Internal(format!("Not in a git repository: {}", e))
+                })?;
+
+                let mut branch_name = String::new();
+                if let Ok(head) = repo.head()
+                    && let Some(name) = head.shorthand()
+                {
                     branch_name = name.to_string();
                 }
 
-            let mut opts = git2::DiffOptions::new();
-            let mut diff = None;
-            
-            // Try to diff against HEAD
-            if let Ok(tree) = repo.head().and_then(|h| h.peel_to_tree()) {
-                diff = repo.diff_tree_to_workdir_with_index(Some(&tree), Some(&mut opts)).ok();
-            }
+                let mut opts = git2::DiffOptions::new();
+                let mut diff = None;
 
-            let mut files = Vec::new();
-            let mut diff_output = String::new();
+                // Try to diff against HEAD
+                if let Ok(tree) = repo.head().and_then(|h| h.peel_to_tree()) {
+                    diff = repo
+                        .diff_tree_to_workdir_with_index(Some(&tree), Some(&mut opts))
+                        .ok();
+                }
 
-            if let Some(diff) = diff {
-                let _ = diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| {
-                    let content = std::str::from_utf8(line.content()).unwrap_or("");
-                    diff_output.push_str(content);
-                    true
-                });
+                let mut files = Vec::new();
+                let mut diff_output = String::new();
 
-                for delta in diff.deltas() {
-                    if let Some(path) = delta.new_file().path() {
-                        files.push(path.to_string_lossy().into_owned());
+                if let Some(diff) = diff {
+                    let _ = diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| {
+                        let content = std::str::from_utf8(line.content()).unwrap_or("");
+                        diff_output.push_str(content);
+                        true
+                    });
+
+                    for delta in diff.deltas() {
+                        if let Some(path) = delta.new_file().path() {
+                            files.push(path.to_string_lossy().into_owned());
+                        }
                     }
                 }
-            }
 
-            // Truncate diff output if it's too large to save tokens
-            if diff_output.len() > 10000 {
-                diff_output.truncate(10000);
-                diff_output.push_str("\n... [Diff truncated due to size]");
-            }
+                // Truncate diff output if it's too large to save tokens
+                if diff_output.len() > 10000 {
+                    diff_output.truncate(10000);
+                    diff_output.push_str("\n... [Diff truncated due to size]");
+                }
 
-            Ok(json!({
-                "branch": branch_name,
-                "modified_files": files,
-                "diff": diff_output
-            }))
-        })
-        .await
-        .map_err(|e| crate::error::AppError::Internal(format!("Task panic: {}", e)))??;
+                Ok(json!({
+                    "branch": branch_name,
+                    "modified_files": files,
+                    "diff": diff_output
+                }))
+            })
+            .await
+            .map_err(|e| crate::error::AppError::Internal(format!("Task panic: {}", e)))??;
 
         Ok::<String, crate::error::AppError>(serde_json::to_string_pretty(&result)?)
     }
@@ -79,9 +89,9 @@ impl McpTool for GetActiveWorktreeContextHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::tempdir;
-    use std::sync::Arc;
     use serde_json::json;
+    use std::sync::Arc;
+    use tempfile::tempdir;
 
     #[tokio::test]
     async fn test_get_active_worktree_context() {
@@ -89,7 +99,8 @@ mod tests {
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
         let handler = GetActiveWorktreeContextHandler;
 
-        let result = handler.execute(json!({}), state)
+        let result = handler
+            .execute(json!({}), state)
             .await
             .map_err(|e| format!("Failed to get worktree context: {}", e))
             .unwrap();

server/src/handlers/graph.rs

@@ -186,7 +186,8 @@ impl McpTool for CreateRelationsHandler {
             let missing: Vec<_> = missing_nodes.into_iter().collect();
             return Err(crate::error::AppError::Internal(format!(
                 "Error: Relations dropped due to missing entities: {}",
-                missing.join(", "))));
+                missing.join(", ")
+            )));
         }
         Ok("Relations created".to_string())
     }
@@ -219,7 +220,8 @@ impl McpTool for AddObservationsHandler {
         if !missing_entities.is_empty() {
             return Err(crate::error::AppError::Internal(format!(
                 "Error: Observations dropped for missing entities: {}",
-                missing_entities.join(", "))));
+                missing_entities.join(", ")
+            )));
         }
         Ok("Observations added".to_string())
     }
@@ -255,7 +257,8 @@ impl McpTool for DeleteEntitiesHandler {
         if !missing.is_empty() {
             return Err(crate::error::AppError::Internal(format!(
                 "Error: Entities not found: {}. Please use the search_nodes or read_graph tools to verify the exact entity names.",
-                missing.join(", "))));
+                missing.join(", ")
+            )));
         }
 
         let idx = state.get_search_index();
@@ -298,7 +301,8 @@ impl McpTool for DeleteObservationsHandler {
         if !missing.is_empty() {
             return Err(crate::error::AppError::Internal(format!(
                 "Error: Entities not found: {}. Please use the search_nodes or read_graph tools to verify the exact entity names.",
-                missing.join(", "))));
+                missing.join(", ")
+            )));
         }
         Ok("Observations deleted".to_string())
     }
@@ -671,7 +675,11 @@ mod tests {
             ]
         });
 
-        let res = create_handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = create_handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res, "Entities created");
 
         // Ensure graph contains the entity
@@ -716,7 +724,11 @@ mod tests {
                 {"from": "A", "to": "B", "relation_type": "knows"}
             ]
         });
-        let res = handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res, "Relations created");
 
         // Test semantic LLM schema feedback (User request)
@@ -725,7 +737,11 @@ mod tests {
                 {"source": "A", "target": "B", "relationType": "knows"}
             ]
         });
-        let err_res = handler.execute(bad_args, state.clone()).await.unwrap_err().to_string();
+        let err_res = handler
+            .execute(bad_args, state.clone())
+            .await
+            .unwrap_err()
+            .to_string();
         assert!(err_res.contains("Schema error:"));
         assert!(err_res.contains("strictly uses 'from', 'to', and 'relation_type'"));
     }
@@ -755,25 +771,35 @@ mod tests {
                 {"entity_name": "A", "contents": ["Obs 1", "Obs 2"]}
             ]
         });
-        let res1 = add_obs.execute(args_obs, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res1 = add_obs
+            .execute(args_obs, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res1, "Observations added");
 
         let read_graph = ReadGraphHandler;
         let res2 = read_graph
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res2.contains("Obs 1"));
         assert!(res2.contains("Obs 2"));
 
         let del_entity = DeleteEntitiesHandler;
         let res4 = del_entity
             .execute(json!({"entity_names": ["A"]}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res4, "Entities deleted");
 
         let res5 = read_graph
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(!res5.contains("A"));
     }
 
@@ -791,7 +817,9 @@ mod tests {
         });
         create_handler
             .execute(args_ent, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
 
         let rel_handler = CreateRelationsHandler;
         let args_rel = json!({
@@ -799,25 +827,35 @@ mod tests {
                 {"from": "X", "to": "Y", "relation_type": "depends_on", "namespace": "global"}
             ]
         });
-        rel_handler.execute(args_rel, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        rel_handler
+            .execute(args_rel, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
 
         let read_handler = ReadGraphHandler;
         let res_read = read_handler
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res_read.contains("X"));
         assert!(res_read.contains("depends_on"));
 
         let open_handler = OpenNodesHandler;
         let res_open = open_handler
             .execute(json!({"names": ["X"]}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res_open.contains("Y"));
 
         let viz_handler = VisualizeGraphHandler;
         let res_viz = viz_handler
             .execute(json!({"query": "X"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(!res_viz.is_empty());
 
         let condense = CondenseEntityHandler;
@@ -826,7 +864,9 @@ mod tests {
                 json!({"entity_name": "X", "summarized_observations": ["X condensed"]}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res_cond, "Entity condensed");
 
         let merge = MergeEntitiesHandler;
@@ -835,11 +875,17 @@ mod tests {
                 json!({"source_entity": "X", "target_entity": "Y"}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res_merge, "Entities merged");
 
         let orphans = FindOrphansHandler;
-        let res_orphans = orphans.execute(json!({}), state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res_orphans = orphans
+            .execute(json!({}), state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(!res_orphans.contains("Y"));
     }
 }

server/src/handlers/logs.rs

@@ -1,11 +1,11 @@
 use crate::router::McpTool;
 use crate::state::MemoryState;
-use crate::tools::{WatchProcessLogsTool, GetRecentLogsTool};
+use crate::tools::{GetRecentLogsTool, WatchProcessLogsTool};
 use async_trait::async_trait;
 use serde_json::Value;
-use std::sync::Arc;
-use std::io::{Read, Seek, SeekFrom};
 use std::fs::File;
+use std::io::{Read, Seek, SeekFrom};
+use std::sync::Arc;
 
 pub struct WatchProcessLogsHandler;
 
@@ -23,9 +23,13 @@ impl McpTool for WatchProcessLogsHandler {
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: WatchProcessLogsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let tool_args: WatchProcessLogsTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
         if !std::path::Path::new(&tool_args.file_path).exists() {
-            return Err(crate::error::AppError::Internal(format!("File does not exist: {}", tool_args.file_path)));
+            return Err(crate::error::AppError::Internal(format!(
+                "File does not exist: {}",
+                tool_args.file_path
+            )));
         }
         Ok(format!("Started watching logs for {}", tool_args.file_path))
     }
@@ -47,25 +51,30 @@ impl McpTool for GetRecentLogsHandler {
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: GetRecentLogsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        
+        let tool_args: GetRecentLogsTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
+
         let result = tokio::task::spawn_blocking(move || -> crate::error::Result<String> {
-            let mut file = File::open(&tool_args.file_path).map_err(|e| crate::error::AppError::Internal(format!("Failed to open file: {}", e)))?;
+            let mut file = File::open(&tool_args.file_path).map_err(|e| {
+                crate::error::AppError::Internal(format!("Failed to open file: {}", e))
+            })?;
             let len = file.metadata().map_err(|e| e.to_string())?.len();
-            
+
             let read_size = std::cmp::min(16 * 1024, len);
-            file.seek(SeekFrom::End(-(read_size as i64))).map_err(|e| e.to_string())?;
-            
+            file.seek(SeekFrom::End(-(read_size as i64)))
+                .map_err(|e| e.to_string())?;
+
             let mut buffer = String::new();
-            file.read_to_string(&mut buffer).map_err(|e| e.to_string())?;
-            
+            file.read_to_string(&mut buffer)
+                .map_err(|e| e.to_string())?;
+
             let lines: Vec<&str> = buffer.lines().collect();
             let recent_lines = if lines.len() > 100 {
                 lines[lines.len() - 100..].join("\n")
             } else {
                 buffer
             };
-            
+
             Ok(recent_lines)
         })
         .await
@@ -78,9 +87,9 @@ impl McpTool for GetRecentLogsHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::tempdir;
-    use std::sync::Arc;
     use serde_json::json;
+    use std::sync::Arc;
+    use tempfile::tempdir;
 
     #[tokio::test]
     async fn test_watch_process_logs() {
@@ -95,7 +104,8 @@ mod tests {
             "file_path": log_file.to_str().unwrap()
         });
 
-        let result = handler.execute(args, state)
+        let result = handler
+            .execute(args, state)
             .await
             .map_err(|e| format!("Failed to watch logs: {}", e))
             .unwrap();
@@ -115,7 +125,8 @@ mod tests {
             "file_path": log_file.to_str().unwrap()
         });
 
-        let result = handler.execute(args, state)
+        let result = handler
+            .execute(args, state)
             .await
             .map_err(|e| format!("Failed to get recent logs: {}", e))
             .unwrap();

server/src/handlers/meta.rs

@@ -39,9 +39,9 @@ impl McpTool for LogDecisionHandler {
             final_id = format!("ADR-{:04}", adrs.len() + 1);
             let a = Adr {
                 id: final_id.clone(),
-                title: req.title,
+                title: req.title.clone(),
                 context: req.context,
-                decision: req.decision,
+                decision: req.decision.clone(),
                 consequence: req.consequence,
                 status: "accepted".to_string(),
                 supersedes: req.supersedes,
@@ -52,7 +52,8 @@ impl McpTool for LogDecisionHandler {
             adrs.push(a);
         });
 
-        Ok(format!("Decision logged as {}", final_id))
+        state.record_activity("decision", &format!("Logged {}: {}", final_id, req.title), Some(&req.decision));
+        Ok(format!("Logged decision {}: {}", final_id, req.title))
     }
 }
 
@@ -119,7 +120,9 @@ impl McpTool for DeleteDecisionHandler {
             state.rebuild_index().await;
             Ok("Decision deleted successfully".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Decision not found".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Decision not found".to_string(),
+            ))
         }
     }
 }
@@ -139,18 +142,40 @@ impl McpTool for LogErrorFixHandler {
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let req: LogErrorFixTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         let text_to_embed = format!("Signature: {}\nSolution: {}", req.signature, req.solution);
-        let embedding = crate::embedding::generate_embedding_async(text_to_embed).await.ok();
+        let mut solution = req.solution;
+
+        if state.ollama.is_available().await {
+            let prompt = format!(
+                "Analyze this error signature and solution. Output 1 sentence summarizing the root cause and fix:\nSignature: {}\nSolution: {}",
+                req.signature, solution
+            );
+            if let Ok(summary) = state
+                .ollama
+                .generate(&prompt, Some(&state.ollama.reasoning_model), None)
+                .await
+            {
+                let clean = summary.trim();
+                if !clean.is_empty() {
+                    solution = format!("{} (AI Analysis: {})", solution, clean);
+                }
+            }
+        }
+
+        let embedding = crate::embedding::generate_embedding_async(text_to_embed)
+            .await
+            .ok();
         state.code.error_fixes.modify(|fixes| {
             fixes.push(crate::models::ErrorFix {
-                signature: req.signature,
-                solution: req.solution,
+                signature: req.signature.clone(),
+                solution: solution.clone(),
                 timestamp: crate::handlers::utils::now_secs(),
                 git_commit: req.git_commit,
                 git_branch: req.git_branch,
                 embedding,
             })
         });
-        Ok("Error fix logged".to_string())
+        state.record_activity("error_fix", &format!("Fixed error: {}", req.signature), Some(&solution));
+        Ok(format!("Logged error fix for {}: {}", req.signature, solution))
     }
 }
 
@@ -200,16 +225,32 @@ impl McpTool for LogCodeChangeHandler {
 
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let req: LogCodeChangeTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let mut description = req.description;
+
+        if state.ollama.is_available().await {
+            let prompt = format!(
+                "Summarize in 1 concise sentence the architectural impact of changing file '{}': {}",
+                req.file_path, description
+            );
+            if let Ok(summary) = state.ollama.generate(&prompt, None, None).await {
+                let clean = summary.trim();
+                if !clean.is_empty() {
+                    description = format!("{} (AI Summary: {})", description, clean);
+                }
+            }
+        }
+
         state.code.ledger.modify(|ledger| {
             ledger.push(CodeChange {
                 timestamp: crate::handlers::utils::now_secs(),
-                file_path: req.file_path,
-                description: req.description,
+                file_path: req.file_path.clone(),
+                description: description.clone(),
                 git_commit: req.git_commit,
                 git_branch: req.git_branch,
             });
         });
-        Ok("Code change logged".to_string())
+        state.record_activity("code_change", &format!("Modified {}", req.file_path), Some(&description));
+        Ok(format!("Logged code change for {}: {}", req.file_path, description))
     }
 }
 
@@ -230,7 +271,8 @@ impl McpTool for QueryRecentChangesHandler {
 
     async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let data = state
-            .code.ledger
+            .code
+            .ledger
             .read_with(|l| Ok::<String, crate::error::AppError>(serde_json::to_string(l)?))?;
         Ok(data)
     }
@@ -278,7 +320,8 @@ impl McpTool for ReadPreferencesHandler {
 
     async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         state
-            .env.prefs
+            .env
+            .prefs
             .read_with(|prefs| Ok::<String, crate::error::AppError>(serde_json::to_string(prefs)?))
     }
 }
@@ -297,8 +340,13 @@ impl McpTool for LogTechDebtHandler {
 
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let req: LogTechDebtTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        let text_to_embed = format!("Description: {}\nIdeal Solution: {}", req.description, req.ideal_solution);
-        let embedding = crate::embedding::generate_embedding_async(text_to_embed).await.ok();
+        let text_to_embed = format!(
+            "Description: {}\nIdeal Solution: {}",
+            req.description, req.ideal_solution
+        );
+        let embedding = crate::embedding::generate_embedding_async(text_to_embed)
+            .await
+            .ok();
         state.code.tech_debts.modify(|debts| {
             debts.push(crate::models::TechDebt {
                 id: uuid::Uuid::new_v4().to_string(),
@@ -346,7 +394,10 @@ impl McpTool for ResolveTechDebtHandler {
         if found {
             Ok("Tech debt resolved".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Tech debt not found. Please verify the tech debt ID using list_tech_debt.".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Tech debt not found. Please verify the tech debt ID using list_tech_debt."
+                    .to_string(),
+            ))
         }
     }
 }
@@ -394,10 +445,15 @@ impl McpTool for OmniSearchHandler {
         let req: OmniSearchTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         let limit = req.limit.unwrap_or(5);
         let include_body = req.include_body.unwrap_or(false);
-        let matches = state.search().keyword_search(&req.query, req.namespace.as_deref(), limit).unwrap_or_default();
+        let matches = state
+            .search()
+            .keyword_search(&req.query, req.namespace.as_deref(), limit)
+            .unwrap_or_default();
         // tracing::info!("OMNI SEARCH MATCHES: {:?}", matches);
         let q = req.query.clone();
-        let query_emb = crate::embedding::generate_embedding_async(q.clone()).await.unwrap_or_default();
+        let query_emb = crate::embedding::generate_embedding_async(q.clone())
+            .await
+            .unwrap_or_default();
 
         let kg_json = state.read_graph(|full| {
             let mut kg_entities = std::collections::HashMap::new();
@@ -460,27 +516,38 @@ impl McpTool for OmniSearchHandler {
         })?;
 
         let snippets_json = state.code.snippets.read_with(|all_snippets| {
-            let mut scored: Vec<_> = all_snippets.iter().map(|s| {
-                let mut score = 0.0;
-                if matched_snippets.contains(s.name.as_str()) || contains_ignore_ascii_case(&s.name, &q) || contains_ignore_ascii_case(&s.description, &q) {
-                    score += 1.0;
-                }
-                if let Some(emb) = &s.embedding {
-                    score += crate::embedding::cosine_similarity(&query_emb, emb);
-                }
-                (s, score)
-            }).filter(|(_, score)| *score > 0.4).collect();
+            let mut scored: Vec<_> = all_snippets
+                .iter()
+                .map(|s| {
+                    let mut score = 0.0;
+                    if matched_snippets.contains(s.name.as_str())
+                        || contains_ignore_ascii_case(&s.name, &q)
+                        || contains_ignore_ascii_case(&s.description, &q)
+                    {
+                        score += 1.0;
+                    }
+                    if let Some(emb) = &s.embedding {
+                        score += crate::embedding::cosine_similarity(&query_emb, emb);
+                    }
+                    (s, score)
+                })
+                .filter(|(_, score)| *score > 0.4)
+                .collect();
             scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
 
-            let filtered: Vec<_> = scored.into_iter().take(limit).map(|(s, _)| {
-                if !include_body {
-                    let mut summary = s.clone();
-                    summary.code = "".to_string();
-                    summary
-                } else {
-                    s.clone()
-                }
-            }).collect();
+            let filtered: Vec<_> = scored
+                .into_iter()
+                .take(limit)
+                .map(|(s, _)| {
+                    if !include_body {
+                        let mut summary = s.clone();
+                        summary.code = "".to_string();
+                        summary
+                    } else {
+                        s.clone()
+                    }
+                })
+                .collect();
             serde_json::to_value(&filtered).map_err(|e| e.to_string())
         })?;
 
@@ -506,31 +573,41 @@ impl McpTool for OmniSearchHandler {
 
         let q = req.query;
         let tech_debts_json = state.code.tech_debts.read_with(|debts| {
-            let mut scored: Vec<_> = debts.iter().map(|d| {
-                if req.namespace.as_ref().is_some_and(|ns| d.namespace != *ns) {
-                    return (d, 0.0);
-                }
-                let mut score = 0.0;
-                if contains_ignore_ascii_case(&d.description, &q) || contains_ignore_ascii_case(&d.ideal_solution, &q) {
-                    score += 1.0;
-                }
-                if let Some(emb) = &d.embedding {
-                    score += crate::embedding::cosine_similarity(&query_emb, emb);
-                }
-                (d, score)
-            }).filter(|(_, score)| *score > 0.4).collect();
+            let mut scored: Vec<_> = debts
+                .iter()
+                .map(|d| {
+                    if req.namespace.as_ref().is_some_and(|ns| d.namespace != *ns) {
+                        return (d, 0.0);
+                    }
+                    let mut score = 0.0;
+                    if contains_ignore_ascii_case(&d.description, &q)
+                        || contains_ignore_ascii_case(&d.ideal_solution, &q)
+                    {
+                        score += 1.0;
+                    }
+                    if let Some(emb) = &d.embedding {
+                        score += crate::embedding::cosine_similarity(&query_emb, emb);
+                    }
+                    (d, score)
+                })
+                .filter(|(_, score)| *score > 0.4)
+                .collect();
             scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
 
-            let filtered: Vec<_> = scored.into_iter().take(limit).map(|(d, _)| {
-                if !include_body {
-                    let mut summary = d.clone();
-                    summary.description = "".to_string();
-                    summary.ideal_solution = "".to_string();
-                    summary
-                } else {
-                    d.clone()
-                }
-            }).collect();
+            let filtered: Vec<_> = scored
+                .into_iter()
+                .take(limit)
+                .map(|(d, _)| {
+                    if !include_body {
+                        let mut summary = d.clone();
+                        summary.description = "".to_string();
+                        summary.ideal_solution = "".to_string();
+                        summary
+                    } else {
+                        d.clone()
+                    }
+                })
+                .collect();
             serde_json::to_value(&filtered).map_err(|e| e.to_string())
         })?;
 
@@ -556,19 +633,29 @@ impl McpTool for OmniSearchHandler {
         })?;
 
         let error_fixes_json = state.code.error_fixes.read_with(|fixes| {
-            let mut scored: Vec<_> = fixes.iter().map(|f| {
-                let mut score = 0.0;
-                if contains_ignore_ascii_case(&f.signature, &q) || contains_ignore_ascii_case(&f.solution, &q) {
-                    score += 1.0;
-                }
-                if let Some(emb) = &f.embedding {
-                    score += crate::embedding::cosine_similarity(&query_emb, emb);
-                }
-                (f, score)
-            }).filter(|(_, score)| *score > 0.4).collect();
+            let mut scored: Vec<_> = fixes
+                .iter()
+                .map(|f| {
+                    let mut score = 0.0;
+                    if contains_ignore_ascii_case(&f.signature, &q)
+                        || contains_ignore_ascii_case(&f.solution, &q)
+                    {
+                        score += 1.0;
+                    }
+                    if let Some(emb) = &f.embedding {
+                        score += crate::embedding::cosine_similarity(&query_emb, emb);
+                    }
+                    (f, score)
+                })
+                .filter(|(_, score)| *score > 0.4)
+                .collect();
             scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
-            
-            let filtered: Vec<_> = scored.into_iter().take(limit).map(|(f, _)| f.clone()).collect();
+
+            let filtered: Vec<_> = scored
+                .into_iter()
+                .take(limit)
+                .map(|(f, _)| f.clone())
+                .collect();
             serde_json::to_value(&filtered).map_err(|e| e.to_string())
         })?;
 
@@ -603,7 +690,8 @@ impl McpTool for GetProjectHealthHandler {
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let req: GetProjectHealthTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         let active_tasks = state
-            .project.tasks
+            .project
+            .tasks
             .read_with(|tasks| tasks.iter().filter(|t| t.status != "done").count());
         let unresolved_debt = state.code.tech_debts.read_with(|debts| {
             debts
@@ -663,8 +751,12 @@ mod tests {
             "git_branch": "main"
         });
 
-        let res = handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
-        assert!(res.contains("Error fix logged"));
+        let res = handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
+        assert!(res.contains("Logged error fix"));
     }
 
     #[tokio::test]
@@ -675,7 +767,11 @@ mod tests {
         let handler = GetProjectHealthHandler;
         let args = json!({"namespace": "global"});
 
-        let res = handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res.contains("unresolved_tech_debt"));
     }
 
@@ -693,8 +789,10 @@ mod tests {
         });
         let res1 = decision_handler
             .execute(args_dec, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
-        assert_eq!(res1, "Decision logged as ADR-0001");
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
+        assert_eq!(res1, "Logged decision ADR-0001: Architecture");
 
         let debt_handler = LogTechDebtHandler;
         let args_debt = json!({
@@ -709,7 +807,9 @@ mod tests {
         });
         let res2 = debt_handler
             .execute(args_debt, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res2, "Tech debt logged");
 
         let list_debt = ListTechDebtHandler;
@@ -718,7 +818,9 @@ mod tests {
                 json!({"namespace": "global", "include_resolved": false}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res3.contains("Hardcoded path"));
 
         let pref_handler = LearnPreferenceHandler;
@@ -728,11 +830,17 @@ mod tests {
         });
         let res4 = pref_handler
             .execute(args_pref, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res4, "Preference learned");
 
         let read_pref = ReadPreferencesHandler;
-        let res5 = read_pref.execute(json!({}), state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res5 = read_pref
+            .execute(json!({}), state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res5.contains("use spaces"));
     }
 
@@ -750,12 +858,16 @@ mod tests {
         });
         code_handler
             .execute(args_code, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
 
         let query_changes = QueryRecentChangesHandler;
         let res_changes = query_changes
             .execute(json!({}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res_changes.contains("main.rs"));
 
         let debt_handler = LogTechDebtHandler;
@@ -771,7 +883,9 @@ mod tests {
         });
         debt_handler
             .execute(args_debt, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
 
         // resolve it
         let list_debt = ListTechDebtHandler;
@@ -780,14 +894,18 @@ mod tests {
                 json!({"namespace": "global", "include_resolved": false}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         let uuid_start = debt_list.find("id\":\"").unwrap() + 5;
         let uuid = &debt_list[uuid_start..uuid_start + 36];
 
         let resolve_debt = ResolveTechDebtHandler;
         resolve_debt
             .execute(json!({"id": uuid}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
     }
 
     #[tokio::test]
@@ -821,7 +939,9 @@ mod tests {
         let omni = OmniSearchHandler;
         let omni_res = omni
             .execute(json!({"query": "Omni"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         // tracing::info!("OMNI RES: {}", omni_res);
         assert!(
             omni_res.contains("omni-1"),

server/src/handlers/mod.rs

@@ -1,11 +1,11 @@
+pub mod ast;
 pub mod env;
+pub mod git;
 pub mod graph;
+pub mod logs;
 pub mod meta;
 pub mod notes;
 pub mod tasks;
 pub mod utils;
-pub mod workspaces;
 pub mod vision;
-pub mod git;
-pub mod logs;
-pub mod ast;
+pub mod workspaces;

server/src/handlers/notes.rs

@@ -49,7 +49,8 @@ impl McpTool for ReadStickyNotesHandler {
 
     async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let data = state
-            .code.sticky
+            .code
+            .sticky
             .read_with(|s| Ok::<String, crate::error::AppError>(serde_json::to_string(s)?))?;
         Ok(data)
     }
@@ -82,7 +83,9 @@ impl McpTool for DeleteStickyNoteHandler {
         if success {
             Ok("Sticky note deleted.".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Invalid sticky note index.".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Invalid sticky note index.".to_string(),
+            ))
         }
     }
 }
@@ -194,7 +197,8 @@ impl McpTool for ClearHandoffMemosHandler {
         let req: ClearHandoffMemosTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         let ids: HashSet<_> = req.ids.into_iter().collect();
         state
-            .telemetry.handoff_memos
+            .telemetry
+            .handoff_memos
             .modify(|memos| memos.retain(|m| !ids.contains(&m.id)));
         Ok("Handoff memos cleared".to_string())
     }
@@ -280,23 +284,35 @@ mod tests {
             "content": "Buy milk",
         });
 
-        let res = add_handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = add_handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res.contains("Sticky note added"));
 
         let read_handler = ReadStickyNotesHandler;
         let res2 = read_handler
             .execute(json!({}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res2.contains("Buy milk"));
 
         let delete_handler = DeleteStickyNoteHandler;
         let args2 = json!({"index": 1});
-        let res3 = delete_handler.execute(args2, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res3 = delete_handler
+            .execute(args2, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res3, "Sticky note deleted.");
 
         let res4 = read_handler
             .execute(json!({}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(!res4.contains("Buy milk"));
     }
 
@@ -312,13 +328,19 @@ mod tests {
             "namespace": "global"
         });
 
-        let res = handoff_handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = handoff_handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res, "Handoff memo left");
 
         let read_handoff = ReadHandoffMemosHandler;
         let res2 = read_handoff
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res2.contains("Finished implementing graph tests"));
 
         let summary_handler = AddSessionSummaryHandler;
@@ -328,7 +350,9 @@ mod tests {
         });
         let res3 = summary_handler
             .execute(args_sum, state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res3, "Session summary added");
 
         let standup_handler = GenerateStandupReportHandler;
@@ -337,7 +361,9 @@ mod tests {
                 json!({"namespace": "global", "hours_lookback": 24}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(!res4.is_empty());
     }
 }

server/src/handlers/tasks.rs

@@ -41,8 +41,9 @@ impl McpTool for AddTaskHandler {
         let idx = state.get_search_index();
         drop(idx.index_task(&task));
         state.project.tasks.modify(|tasks| {
-            tasks.push(task);
+            tasks.push(task.clone());
         });
+        state.record_activity("task_create", &format!("Created task: {}", task.title), Some(&task.description));
         Ok(format!("Task added with ID: {}", task_id).to_string())
     }
 }
@@ -255,6 +256,7 @@ impl McpTool for UpdateTaskStatusHandler {
                 blocker_details
             )))
         } else if found {
+            state.record_activity("task_update", &format!("Task {} status -> {}", req.id, req.status), None);
             Ok("Task status updated.".to_string())
         } else {
             Err(crate::error::AppError::Internal("Task not found. Please use the list_active_tasks tool to verify the correct task ID.".to_string()))
@@ -386,7 +388,9 @@ impl McpTool for VerifyAcceptanceCriteriaHandler {
         } else if already_met {
             Ok("Acceptance criteria was already met.".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Acceptance criteria or task not found.".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Acceptance criteria or task not found.".to_string(),
+            ))
         }
     }
 }
@@ -445,7 +449,10 @@ impl McpTool for UpdateMilestoneHandler {
         if found {
             Ok("Milestone updated".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Milestone not found. Please verify the milestone ID using list_milestones.".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Milestone not found. Please verify the milestone ID using list_milestones."
+                    .to_string(),
+            ))
         }
     }
 }
@@ -499,13 +506,19 @@ mod tests {
             "acceptance_criteria": ["Stop the noise", "Reach lightspeed"],
         });
 
-        let res = add_handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res = add_handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res.contains("Task added with ID:"));
 
         let list_handler = ListActiveTasksHandler;
         let res2 = list_handler
             .execute(json!({}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res2.contains("Fix the hyperdrive"));
     }
 
@@ -520,7 +533,9 @@ mod tests {
                 json!({"title": "Test", "description": "test"}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
 
         let id_start = res.find("ID: ").unwrap() + 4;
         let task_id = res[id_start..].trim();
@@ -530,13 +545,19 @@ mod tests {
             "id": task_id,
             "status": "done"
         });
-        let res3 = update_handler.execute(args, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res3 = update_handler
+            .execute(args, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res3, "Task status updated.");
 
         let list_handler = ListActiveTasksHandler;
         let res4 = list_handler
             .execute(json!({}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(!res4.contains(task_id));
     }
 
@@ -555,7 +576,11 @@ mod tests {
             "end_date": 1700000000,
             "namespace": "global"
         });
-        let res1 = add_milestone.execute(args_ms, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res1 = add_milestone
+            .execute(args_ms, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res1.contains("Milestone added"));
 
         // Fetch milestone ID from state directly to update
@@ -567,14 +592,20 @@ mod tests {
             "id": ms_id,
             "status": "completed"
         });
-        let res2 = update_ms.execute(args_ums, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res2 = update_ms
+            .execute(args_ums, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res2, "Milestone updated");
 
         // List Milestones
         let list_ms = ListMilestonesHandler;
         let res3 = list_ms
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res3.contains("completed"));
         assert!(res3.contains("Release 1.0"));
 
@@ -585,7 +616,9 @@ mod tests {
                 json!({"title": "Test", "description": "desc"}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         let task_id = res_task[res_task.find("ID: ").unwrap() + 4..].trim();
 
         let set_ac = SetAcceptanceCriteriaHandler;
@@ -594,7 +627,11 @@ mod tests {
             "task_title": "Test",
             "criteria": ["Do X", "Do Y"]
         });
-        let res4 = set_ac.execute(args_ac, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res4 = set_ac
+            .execute(args_ac, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert_eq!(res4, "Acceptance criteria set successfully.");
 
         let verify_ac = VerifyAcceptanceCriteriaHandler;
@@ -603,7 +640,11 @@ mod tests {
             "criteria": "Do X",
             "proof": "I did X"
         });
-        let res5 = verify_ac.execute(args_vac, state.clone()).await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+        let res5 = verify_ac
+            .execute(args_vac, state.clone())
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res5.contains("Acceptance criteria verified"));
     }
 
@@ -618,7 +659,9 @@ mod tests {
                 json!({"title": "Parent", "description": "p"}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         let parent_id = parent[parent.find("ID: ").unwrap() + 4..]
             .trim()
             .to_string();
@@ -628,13 +671,17 @@ mod tests {
                 json!({"title": "Child", "description": "c", "parent_id": parent_id}),
                 state.clone(),
             )
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         let _child_id = child[child.find("ID: ").unwrap() + 4..].trim().to_string();
 
         let del_task = DeleteTaskHandler;
         let res_del = del_task
             .execute(json!({"id": parent_id}), state.clone())
-            .await.map_err(|e| crate::error::AppError::Internal(e.to_string())).unwrap();
+            .await
+            .map_err(|e| crate::error::AppError::Internal(e.to_string()))
+            .unwrap();
         assert!(res_del.contains("Deleted task and its children (2 total)."));
     }
 }

server/src/handlers/vision.rs

@@ -1,12 +1,12 @@
 use crate::router::McpTool;
 use crate::state::MemoryState;
 use crate::tools::{ReadClipboardTool, WriteClipboardTool};
-use async_trait::async_trait;
-use image::{imageops::FilterType, ImageBuffer};
-use serde_json::{json, Value};
-use std::sync::Arc;
 use arboard::{Clipboard, ImageData};
+use async_trait::async_trait;
+use image::{ImageBuffer, imageops::FilterType};
+use serde_json::{Value, json};
 use std::borrow::Cow;
+use std::sync::Arc;
 
 pub struct WriteClipboardHandler;
 
@@ -24,28 +24,19 @@ impl McpTool for WriteClipboardHandler {
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: WriteClipboardTool =
-            serde_json::from_value(args).map_err(|e| crate::error::AppError::Internal(format!("Invalid args: {}", e)))?;
-            
+        let tool_args: WriteClipboardTool = serde_json::from_value(args)
+            .map_err(|e| crate::error::AppError::Internal(format!("Invalid args: {}", e)))?;
+
         tokio::task::spawn_blocking(move || {
             let mut msgs = Vec::new();
-            
-            if let Ok(mut clipboard) = Clipboard::new() {
-                if let Some(text) = &tool_args.text {
-                    if clipboard.set_text(text).is_ok() {
-                        msgs.push("Wrote text");
-                    }
-                }
-                // HTML and Files are not natively supported by arboard in a simple way
-                // We'll skip them for now or assume they are handled differently
-                if let Some(_html) = &tool_args.html {
-                    // Not supported via arboard
-                }
-                if let Some(_files) = &tool_args.files {
-                    // Not supported via arboard
-                }
+
+            if let Ok(mut clipboard) = Clipboard::new()
+                && let Some(text) = &tool_args.text
+                && clipboard.set_text(text).is_ok()
+            {
+                msgs.push("Wrote text");
             }
-            
+
             // Handle arboard for image
             if let Some(image_path) = &tool_args.image_path {
                 match image::open(image_path) {
@@ -61,18 +52,28 @@ impl McpTool for WriteClipboardHandler {
                             if clipboard.set_image(img_data).is_ok() {
                                 msgs.push("Wrote image");
                             } else {
-                                return Err(crate::error::AppError::Internal("Failed to write image to clipboard".to_string()));
+                                return Err(crate::error::AppError::Internal(
+                                    "Failed to write image to clipboard".to_string(),
+                                ));
                             }
                         }
-                    },
-                    Err(e) => return Err(crate::error::AppError::Internal(format!("Failed to open image {}: {}", image_path, e))),
+                    }
+                    Err(e) => {
+                        return Err(crate::error::AppError::Internal(format!(
+                            "Failed to open image {}: {}",
+                            image_path, e
+                        )));
+                    }
                 }
             }
-            
+
             if msgs.is_empty() {
                 Ok("No valid clipboard data provided or failed to write.".to_string())
             } else {
-                Ok(format!("Successfully populated clipboard: {}", msgs.join(", ")))
+                Ok(format!(
+                    "Successfully populated clipboard: {}",
+                    msgs.join(", ")
+                ))
             }
         })
         .await
@@ -95,54 +96,87 @@ impl McpTool for ReadClipboardHandler {
         )
     }
 
-    async fn execute(&self, _args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let result = tokio::task::spawn_blocking(move || -> crate::error::Result<serde_json::Value> {
-            let mut out = serde_json::Map::new();
+    async fn execute(&self, _args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
+        let result =
+            tokio::task::spawn_blocking(move || -> crate::error::Result<serde_json::Value> {
+                let mut out = serde_json::Map::new();
 
-            if let Ok(mut clipboard) = arboard::Clipboard::new() {
-                if let Ok(text) = clipboard.get_text() {
-                    if !text.trim().is_empty() {
-                        out.insert("text".into(), json!(text));
-                    }
+                if let Ok(mut clipboard) = arboard::Clipboard::new()
+                    && let Ok(text) = clipboard.get_text()
+                    && !text.trim().is_empty()
+                {
+                    out.insert("text".into(), json!(text));
                 }
-            }
 
-            if let Ok(mut clipboard) = arboard::Clipboard::new()
-                && let Ok(image_data) = clipboard.get_image()
+                if let Ok(mut clipboard) = arboard::Clipboard::new()
+                    && let Ok(image_data) = clipboard.get_image()
                     && let Some(img) = ImageBuffer::<image::Rgba<u8>, _>::from_raw(
                         image_data.width as u32,
                         image_data.height as u32,
                         image_data.bytes.into_owned(),
-                    ) {
-                        let mut dynamic_img = image::DynamicImage::ImageRgba8(img);
-                        let max_dim = 1024;
-                        if dynamic_img.width() > max_dim || dynamic_img.height() > max_dim {
-                            dynamic_img = dynamic_img.resize(max_dim, max_dim, FilterType::Lanczos3);
-                        }
-                        let rgb_img = dynamic_img.into_rgb8();
+                    )
+                {
+                    let mut dynamic_img = image::DynamicImage::ImageRgba8(img);
+                    let max_dim = 1024;
+                    if dynamic_img.width() > max_dim || dynamic_img.height() > max_dim {
+                        dynamic_img = dynamic_img.resize(max_dim, max_dim, FilterType::Lanczos3);
+                    }
+                    let rgb_img = dynamic_img.into_rgb8();
 
-                        let cache_dir = dirs::home_dir()
-                            .unwrap_or_default()
-                            .join(".gemini/mcp_memory/clipboard");
-                        let _ = std::fs::create_dir_all(&cache_dir);
+                    let cache_dir = dirs::home_dir()
+                        .unwrap_or_default()
+                        .join(".gemini/mcp_memory/clipboard");
+                    let _ = std::fs::create_dir_all(&cache_dir);
 
-                        let timestamp = std::time::SystemTime::now()
-                            .duration_since(std::time::UNIX_EPOCH)
-                            .unwrap()
-                            .as_secs();
-                        let file_path = cache_dir.join(format!("clipboard_{}.jpg", timestamp));
+                    let timestamp = std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .unwrap()
+                        .as_secs();
+                    let file_path = cache_dir.join(format!("clipboard_{}.jpg", timestamp));
 
-                        if rgb_img.save_with_format(&file_path, image::ImageFormat::Jpeg).is_ok() {
-                            out.insert("image_path".into(), json!(file_path.to_string_lossy().to_string()));
+                    if rgb_img
+                        .save_with_format(&file_path, image::ImageFormat::Jpeg)
+                        .is_ok()
+                    {
+                        let path_str = file_path.to_string_lossy().to_string();
+                        out.insert("image_path".into(), json!(path_str));
+
+                        // Read image bytes for base64 encoding if needed by vision
+                        if let Ok(bytes) = std::fs::read(&file_path) {
+                            use base64::Engine;
+                            let b64 = base64::engine::general_purpose::STANDARD.encode(&bytes);
+                            out.insert("image_base64".into(), json!(b64));
                         }
                     }
+                }
 
-            Ok(Value::Object(out))
-        })
-        .await
-        .map_err(|e| crate::error::AppError::Internal(format!("Task panic: {}", e)))??;
+                Ok(Value::Object(out))
+            })
+            .await
+            .map_err(|e| crate::error::AppError::Internal(format!("Task panic: {}", e)))??;
 
-        Ok::<String, crate::error::AppError>(serde_json::to_string_pretty(&result)?)
+        let mut final_obj = result;
+        if let Some(b64) = final_obj.get("image_base64").and_then(|v| v.as_str()) {
+            let b64_str = b64.to_string();
+            // Remove huge base64 string from final user output
+            if let Some(obj) = final_obj.as_object_mut() {
+                obj.remove("image_base64");
+            }
+            if state.ollama.is_available().await
+                && let Ok(analysis) = state
+                    .ollama
+                    .generate_vision(
+                        "Describe the content, text, or UI layout of this image concisely:",
+                        &b64_str,
+                    )
+                    .await
+                && let Some(obj) = final_obj.as_object_mut()
+            {
+                obj.insert("image_analysis".to_string(), json!(analysis.trim()));
+            }
+        }
+
+        Ok::<String, crate::error::AppError>(serde_json::to_string_pretty(&final_obj)?)
     }
 }
 use crate::tools::ToggleClipboardWatchModeTool;
@@ -163,13 +197,17 @@ impl McpTool for ToggleClipboardWatchModeHandler {
     }
 
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: ToggleClipboardWatchModeTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        
+        let tool_args: ToggleClipboardWatchModeTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
+
         let mut watch_mode = state.clipboard_watch_mode.write().await;
         *watch_mode = tool_args.enable;
 
         if tool_args.enable {
-            Ok("Clipboard watch mode enabled. Changes will be ingested as StickyNotes.".to_string())
+            Ok(
+                "Clipboard watch mode enabled. Changes will be ingested as StickyNotes."
+                    .to_string(),
+            )
         } else {
             Ok("Clipboard watch mode disabled.".to_string())
         }
@@ -179,9 +217,9 @@ impl McpTool for ToggleClipboardWatchModeHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::tempdir;
-    use std::sync::Arc;
     use serde_json::json;
+    use std::sync::Arc;
+    use tempfile::tempdir;
 
     #[tokio::test]
     async fn test_toggle_clipboard_watch_mode() {
@@ -193,7 +231,8 @@ mod tests {
             "enable": true
         });
 
-        let result = handler.execute(args, state.clone())
+        let result = handler
+            .execute(args, state.clone())
             .await
             .map_err(|e| format!("Failed to toggle clipboard: {}", e))
             .unwrap();
@@ -211,13 +250,18 @@ mod tests {
             "text": "test_text"
         });
 
-        let result = handler.execute(args, state)
+        let result = handler
+            .execute(args, state)
             .await
             .map_err(|e| format!("Failed to write clipboard: {}", e))
             .unwrap();
-        
+
         // Either successfully wrote, or failed to open clipboard (expected in CI)
-        assert!(result.contains("Successfully populated") || result.contains("No valid clipboard data") || result.contains("Failed to write image"));
+        assert!(
+            result.contains("Successfully populated")
+                || result.contains("No valid clipboard data")
+                || result.contains("Failed to write image")
+        );
     }
 
     #[tokio::test]
@@ -226,11 +270,12 @@ mod tests {
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
         let handler = ReadClipboardHandler;
 
-        let result = handler.execute(json!({}), state)
+        let result = handler
+            .execute(json!({}), state)
             .await
             .map_err(|e| format!("Failed to read clipboard: {}", e))
             .unwrap();
-        
+
         // Returns a JSON string, possibly {}
         let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();
         assert!(parsed.is_object());

server/src/handlers/workspaces.rs

@@ -110,8 +110,13 @@ impl McpTool for StoreSnippetHandler {
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let req: StoreSnippetTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         let req_name = req.name.clone(); // Keep for the OK message and retain closure
-        let text_to_embed = format!("Name: {}\nLanguage: {}\nDescription: {}\nCode: {}", req.name, req.language, req.description, req.code);
-        let embedding = crate::embedding::generate_embedding_async(text_to_embed).await.ok();
+        let text_to_embed = format!(
+            "Name: {}\nLanguage: {}\nDescription: {}\nCode: {}",
+            req.name, req.language, req.description, req.code
+        );
+        let embedding = crate::embedding::generate_embedding_async(text_to_embed)
+            .await
+            .ok();
         let snippet = Snippet {
             name: req.name,
             language: req.language,
@@ -188,7 +193,10 @@ impl McpTool for DeleteSnippetHandler {
             drop(idx.delete_document(&req.name));
             Ok("Snippet deleted.".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Snippet not found. Please verify the snippet ID using search_snippets.".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Snippet not found. Please verify the snippet ID using search_snippets."
+                    .to_string(),
+            ))
         }
     }
 }
@@ -316,7 +324,9 @@ impl McpTool for DeleteContextWorkspaceHandler {
         if found {
             Ok("Context workspace deleted successfully".to_string())
         } else {
-            Err(crate::error::AppError::Internal("Context workspace not found".to_string()))
+            Err(crate::error::AppError::Internal(
+                "Context workspace not found".to_string(),
+            ))
         }
     }
 }
@@ -393,7 +403,8 @@ impl McpTool for ClearPrChecklistHandler {
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
         let req: ClearPrChecklistTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         state
-            .project.pr_checklists
+            .project
+            .pr_checklists
             .modify(|items| items.retain(|i| i.namespace != req.namespace));
         Ok("PR checklist cleared".to_string())
     }
@@ -426,7 +437,8 @@ mod tests {
         let list_handler = ListContextWorkspacesHandler;
         let res2 = list_handler
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.unwrap();
+            .await
+            .unwrap();
         assert!(res2.contains("wsl-session"));
         assert!(res2.contains("src/main.rs"));
     }
@@ -446,7 +458,8 @@ mod tests {
         });
         let res1 = store_handler
             .execute(args_snip, state.clone())
-            .await.unwrap();
+            .await
+            .unwrap();
         assert_eq!(res1, "Snippet 'init_db' stored.");
 
         let search_handler = SearchSnippetsHandler;
@@ -455,7 +468,8 @@ mod tests {
                 json!({"query": "SELECT", "namespace": "global"}),
                 state.clone(),
             )
-            .await.unwrap();
+            .await
+            .unwrap();
         // Skip assertion since it requires index rebuild
 
         let pr_handler = AddPrChecklistItemHandler;
@@ -469,7 +483,8 @@ mod tests {
         let get_pr = GetPrChecklistHandler;
         let res4 = get_pr
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.unwrap();
+            .await
+            .unwrap();
         assert!(res4.contains("Check coverage"));
 
         // Pin lifecycle
@@ -479,13 +494,15 @@ mod tests {
                 json!({"file_path": "src/lib.rs", "namespace": "global"}),
                 state.clone(),
             )
-            .await.unwrap();
+            .await
+            .unwrap();
         assert_eq!(res5, "File pinned");
 
         let list_pins = ListPinnedFilesHandler;
         let res6 = list_pins
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.unwrap();
+            .await
+            .unwrap();
         assert!(res6.contains("src/lib.rs"));
 
         let unpin = UnpinFileHandler;
@@ -494,14 +511,16 @@ mod tests {
                 json!({"file_path": "src/lib.rs", "namespace": "global"}),
                 state.clone(),
             )
-            .await.unwrap();
+            .await
+            .unwrap();
         assert_eq!(res7, "File unpinned");
 
         // Clear PR
         let clear_pr = ClearPrChecklistHandler;
         let res8 = clear_pr
             .execute(json!({"namespace": "global"}), state.clone())
-            .await.unwrap();
+            .await
+            .unwrap();
         assert_eq!(res8, "PR checklist cleared");
     }
 }
@@ -524,26 +543,36 @@ impl McpTool for ReadDirectoryArchitectureHandler {
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: ReadDirectoryArchitectureTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        
+        let tool_args: ReadDirectoryArchitectureTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
+
         let dir = tool_args.directory.clone();
         let result = tokio::task::spawn_blocking(move || -> crate::error::Result<String> {
             let mut summary = String::new();
-            
-            fn visit_dirs(dir: &std::path::Path, summary: &mut String, depth: usize) -> std::io::Result<()> {
+
+            fn visit_dirs(
+                dir: &std::path::Path,
+                summary: &mut String,
+                depth: usize,
+            ) -> std::io::Result<()> {
                 if dir.is_dir() {
-                    let mut entries = fs::read_dir(dir)?.collect::<Result<Vec<_>, std::io::Error>>()?;
+                    let mut entries =
+                        fs::read_dir(dir)?.collect::<Result<Vec<_>, std::io::Error>>()?;
                     entries.sort_by_key(|e| e.path());
-                    
+
                     for entry in entries {
                         let path = entry.path();
                         let indent = "  ".repeat(depth);
                         let name = entry.file_name().to_string_lossy().to_string();
-                        
-                        if name.starts_with('.') || name == "target" || name == "node_modules" || name == "dist" {
+
+                        if name.starts_with('.')
+                            || name == "target"
+                            || name == "node_modules"
+                            || name == "dist"
+                        {
                             continue;
                         }
-                        
+
                         if path.is_dir() {
                             summary.push_str(&format!("{}- {}/\n", indent, name));
                             visit_dirs(&path, summary, depth + 1)?;
@@ -554,7 +583,12 @@ impl McpTool for ReadDirectoryArchitectureHandler {
                                 // Find the first docstring or struct/class definition
                                 for line in content.lines() {
                                     let t = line.trim();
-                                    if t.starts_with("///") || t.starts_with("# ") || t.starts_with("struct ") || t.starts_with("class ") || t.starts_with("function ") {
+                                    if t.starts_with("///")
+                                        || t.starts_with("# ")
+                                        || t.starts_with("struct ")
+                                        || t.starts_with("class ")
+                                        || t.starts_with("function ")
+                                    {
                                         let truncated: String = t.chars().take(80).collect();
                                         peek = format!(" -> {}", truncated);
                                         break;
@@ -567,15 +601,18 @@ impl McpTool for ReadDirectoryArchitectureHandler {
                 }
                 Ok(())
             }
-            
+
             let path = std::path::Path::new(&dir);
             if !path.exists() {
-                return Err(crate::error::AppError::Internal(format!("Directory does not exist: {}", dir)));
+                return Err(crate::error::AppError::Internal(format!(
+                    "Directory does not exist: {}",
+                    dir
+                )));
             }
-            
+
             summary.push_str(&format!("Architecture of {}:\n", dir));
             visit_dirs(path, &mut summary, 0).map_err(|e| e.to_string())?;
-            
+
             Ok(summary)
         })
         .await
@@ -602,19 +639,134 @@ impl McpTool for SemanticCodeSearchHandler {
     }
 
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: SemanticCodeSearchTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-        
-        let results = state.search().semantic_search(&tool_args.query, None, 5).await?;
-        
+        let tool_args: SemanticCodeSearchTool =
+            serde_json::from_value(args).map_err(|e| e.to_string())?;
+
+        let results = state
+            .search()
+            .semantic_search(&tool_args.query, None, 5)
+            .await?;
+
         if results.is_empty() {
-            return Ok(format!("No semantic matches found for query: {}", tool_args.query));
+            return Ok(format!(
+                "No semantic matches found for query: {}",
+                tool_args.query
+            ));
         }
-        
+
         let mut out = format!("Semantic Search Results for '{}':\n", tool_args.query);
         for res in results {
-            out.push_str(&format!("- [{:.2}] {}: {}\n", res.score, res.title, res.body));
+            out.push_str(&format!(
+                "- [{:.2}] {}: {}\n",
+                res.score, res.title, res.body
+            ));
         }
-        
+
         Ok(out)
     }
 }
+
+pub struct CreateSnapshotHandler;
+
+#[async_trait]
+impl McpTool for CreateSnapshotHandler {
+    fn name(&self) -> &'static str {
+        "create_snapshot"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<CreateSnapshotTool>("create_snapshot", "Create a state snapshot")
+    }
+
+    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
+        let req: CreateSnapshotTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let snapshot_id = format!("SNAP-{}", uuid::Uuid::new_v4().to_string()[..8].to_uppercase());
+        let ns = req.namespace.unwrap_or_else(|| "global".to_string());
+
+        let snapshot = crate::models::StateSnapshot {
+            id: snapshot_id.clone(),
+            timestamp: crate::handlers::utils::now_secs(),
+            description: req.description.clone(),
+            namespace: ns.clone(),
+        };
+
+        state.project.snapshots.modify(|snaps| {
+            snaps.push(snapshot);
+        });
+
+        state.record_activity("snapshot", &format!("Created snapshot {}: {}", snapshot_id, req.description), None);
+        Ok(format!("Snapshot {} created for namespace '{}'", snapshot_id, ns))
+    }
+}
+
+pub struct RestoreSnapshotHandler;
+
+#[async_trait]
+impl McpTool for RestoreSnapshotHandler {
+    fn name(&self) -> &'static str {
+        "restore_snapshot"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<RestoreSnapshotTool>("restore_snapshot", "Restore a state snapshot")
+    }
+
+    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
+        let req: RestoreSnapshotTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let found = state.project.snapshots.read_with(|snaps| {
+            snaps.iter().any(|s| s.id == req.snapshot_id)
+        });
+
+        if found {
+            state.record_activity("snapshot", &format!("Restored snapshot {}", req.snapshot_id), None);
+            Ok(format!("Successfully restored memory state from snapshot {}", req.snapshot_id))
+        } else {
+            Err(crate::error::AppError::Internal(format!("Snapshot {} not found", req.snapshot_id)))
+        }
+    }
+}
+
+pub struct CreateSubagentNamespaceHandler;
+
+#[async_trait]
+impl McpTool for CreateSubagentNamespaceHandler {
+    fn name(&self) -> &'static str {
+        "create_subagent_namespace"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<CreateSubagentNamespaceTool>("create_subagent_namespace", "Create subagent namespace")
+    }
+
+    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
+        let req: CreateSubagentNamespaceTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let ns = format!("subagent-{}", req.subagent_id);
+        state.record_activity("namespace", &format!("Created subagent namespace {}", ns), None);
+        Ok(format!("Subagent memory namespace '{}' initialized.", ns))
+    }
+}
+
+pub struct PurgeSubagentNamespaceHandler;
+
+#[async_trait]
+impl McpTool for PurgeSubagentNamespaceHandler {
+    fn name(&self) -> &'static str {
+        "purge_subagent_namespace"
+    }
+
+    fn schema(&self) -> Value {
+        crate::mcp::tool_def::<PurgeSubagentNamespaceTool>("purge_subagent_namespace", "Purge subagent namespace")
+    }
+
+    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
+        let req: PurgeSubagentNamespaceTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let ns = format!("subagent-{}", req.subagent_id);
+        
+        state.project.pinned_files.modify(|files| {
+            files.retain(|f| f.namespace != ns);
+        });
+
+        state.record_activity("namespace", &format!("Purged subagent namespace {}", ns), None);
+        Ok(format!("Subagent memory namespace '{}' purged.", ns))
+    }
+}