perf: remove redundant MemoryState::deduplicate and resolve lock contention during index rebuild

server/src/handlers/graph.rs

@@ -534,7 +534,8 @@ impl McpTool for MergeEntitiesHandler {
             if let Some(src) = master.entities.remove(&req.source_entity) {
                 if let Some(tgt) = master.entities.get_mut(&req.target_entity) {
                     tgt.observations.extend(src.observations);
-                    MemoryState::deduplicate(&mut tgt.observations);
+                    tgt.observations.sort();
+                    tgt.observations.dedup();
                 } else {
                     let mut new_tgt = src.clone();
                     new_tgt.name = req.target_entity.clone();

server/src/state.rs

@@ -84,10 +84,6 @@ impl MemoryState {
         }
     }
 
-    pub fn deduplicate<T: Eq + std::hash::Hash + Clone>(input: &mut Vec<T>) {
-        let mut keys = std::collections::HashSet::new();
-        input.retain(|entry| keys.insert(entry.clone()));
-    }
 
     pub fn broadcast_activity(&self, message: &str) {
         let time = std::time::SystemTime::now()
@@ -129,33 +125,26 @@ impl MemoryState {
 
     pub async fn rebuild_index(self: &Arc<Self>) {
         if let Ok(new_idx) = MemoryIndex::new(&self.base_dir) {
-            let state = Arc::clone(self);
             let idx = new_idx.clone();
 
+            let entities: Vec<_> = self.graph.read_with(|g| g.entities.values().cloned().collect());
+            let tasks = self.tasks.read_with(|t| t.clone());
+            let snippets = self.snippets.read_with(|s| s.clone());
+            let adrs = self.adrs.read_with(|a| a.clone());
+
             tokio::task::spawn_blocking(move || {
-                state.graph.read_with(|g| {
+                for e in entities {
-                    for e in g.entities.values() {
+                    idx.add_entity_sync(&e);
-                        idx.add_entity_sync(e);
+                }
-                    }
+                for task in tasks {
-                });
+                    idx.add_task_sync(&task);
-
+                }
-                state.tasks.read_with(|t| {
+                for snippet in snippets {
-                    for task in t {
+                    idx.add_snippet_sync(&snippet);
-                        idx.add_task_sync(task);
+                }
-                    }
+                for adr in adrs {
-                });
+                    idx.add_adr_sync(&adr);
-
+                }
-                state.snippets.read_with(|s| {
-                    for snippet in s {
-                        idx.add_snippet_sync(snippet);
-                    }
-                });
-
-                state.adrs.read_with(|a| {
-                    for adr in a {
-                        idx.add_adr_sync(adr);
-                    }
-                });
             })
             .await
             .unwrap_or_else(|e| {