Fix MCP hangs and add logging

server/src/main.rs

@@ -151,13 +151,13 @@ async fn git_sync_worker(state: Arc<MemoryState>) {
                         file_path: "".to_string(),
                     });
                 });
-                eprintln!("Git Sync: Logged new commit {}", current_id);
+                tracing::info!("Git Sync: Logged new commit {}", current_id);
                 
                 state.tasks.modify(|tasks| {
                     for task in tasks.iter_mut() {
                         if task.status != "completed" && msg.to_lowercase().contains(&task.title.to_lowercase()) {
                             task.status = "completed".to_string();
-                            eprintln!("Git Sync: Auto-completed task '{}'", task.title);
+                            tracing::info!("Git Sync: Auto-completed task '{}'", task.title);
                         }
                     }
                 });
@@ -505,8 +505,8 @@ fn run_server(state: Arc<MemoryState>) -> Result<(), Box<dyn std::error::Error>>
         tokio::spawn(garbage_collector_worker(Arc::clone(&state)));
 
         tokio::spawn(git_sync_worker(Arc::clone(&state)));
-eprintln!("MCP Memory Server running on http://127.0.0.1:3000/sse");
-        if let Err(e) = axum::serve(listener, app).await {
+    tracing::info!("MCP Memory Server running on http://127.0.0.1:3000/sse");
+    if let Err(e) = axum::serve(listener, app).await {
             let log_path = dirs::home_dir()
                 .unwrap_or_default()
                 .join(".gemini/mcp_memory/daemon_error.log");
@@ -676,8 +676,32 @@ async fn health_handler() -> &'static str {
     "OK"
 }
 
+fn init_logging(app_name: &str) -> Option<tracing_appender::non_blocking::WorkerGuard> {
+    let base_dir = std::env::var("MCP_MEMORY_STORE_DIR").unwrap_or_else(|_| {
+        dirs::home_dir()
+            .map(|mut h| {
+                h.push(".gemini/mcp_memory");
+                h.to_string_lossy().to_string()
+            })
+            .unwrap_or_else(|| ".gemini/mcp_memory".into())
+    });
+    let log_dir = std::path::PathBuf::from(base_dir).join("logs");
+    std::fs::create_dir_all(&log_dir).unwrap_or_default();
+    
+    let file_appender = tracing_appender::rolling::daily(log_dir, format!("{}.log", app_name));
+    let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
+    
+    let _ = tracing_subscriber::fmt()
+        .with_writer(non_blocking)
+        .with_ansi(false)
+        .with_max_level(tracing::Level::INFO)
+        .try_init();
+    
+    Some(guard)
+}
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let _guard = init_logging("server");
     let cli = Cli::parse();
 
     if cli.exit {

server/src/state.rs

@@ -192,12 +192,12 @@ impl MemoryState {
 
     pub fn rebuild_index(&self) {
         if let Ok(new_idx) = MemoryIndex::new(&self.base_dir) {
-            let session = self.session_graph.read().unwrap();
-            let cache = self.master_cache.read().unwrap();
+            let session_clone = { self.session_graph.read().unwrap().clone() };
+            let cache_clone = { self.master_cache.read().unwrap().0.clone() };
             
             // Index entities that are only in master, or merge if they are in both
-            for (name, e) in &cache.0.entities {
-                if let Some(session_e) = session.entities.get(name) {
+            for (name, e) in &cache_clone.entities {
+                if let Some(session_e) = session_clone.entities.get(name) {
                     let mut merged_e = e.clone();
                     for obs in &session_e.observations {
                         if !merged_e.observations.contains(obs) {
@@ -210,19 +210,22 @@ impl MemoryState {
                 }
             }
             // Index entities that are only in session
-            for (name, session_e) in &session.entities {
-                if !cache.0.entities.contains_key(name) {
+            for (name, session_e) in &session_clone.entities {
+                if !cache_clone.entities.contains_key(name) {
                     let _ = new_idx.index_entity(session_e);
                 }
             }
             
-            for t in self.tasks.read() {
+            let tasks = self.tasks.read();
+            for t in tasks {
                 let _ = new_idx.index_task(&t);
             }
-            for s in self.snippets.read() {
+            let snippets = self.snippets.read();
+            for s in snippets {
                 let _ = new_idx.index_snippet(&s);
             }
-            for a in self.adrs.read() {
+            let adrs = self.adrs.read();
+            for a in adrs {
                 let _ = new_idx.index_adr(&a);
             }
             let _ = new_idx.commit();