fix(common): add cleanup for stale file locks to prevent memory leak

Fixes #5145 and #5142 - File lock HashMaps grow without bound.

Problem: Lock entries accumulate forever without cleanup.

Solution: Added stale lock cleanup mechanism that removes entries where
no external reference exists (strong_count == 1). Cleanup triggers
automatically when the map reaches MAX_LOCK_ENTRIES (10,000).

Author: echobt

src/cortex-common/src/file_locking.rs

@@ -557,6 +557,9 @@ pub async fn atomic_write_async(
         .map_err(|e| FileLockError::AtomicWriteFailed(format!("spawn_blocking failed: {}", e)))?
 }
 
+/// Maximum number of lock entries before triggering cleanup.
+const MAX_LOCK_ENTRIES: usize = 10_000;
+
 /// A file lock manager for coordinating access across multiple operations.
 ///
 /// This is useful when you need to perform multiple operations on a file
@@ -577,15 +580,47 @@ impl FileLockManager {
     ///
     /// This is in addition to the filesystem-level advisory lock and helps
     /// coordinate access within the same process.
+    ///
+    /// Automatically cleans up stale lock entries when the map grows too large.
     pub fn get_lock(&self, path: impl AsRef<Path>) -> Arc<std::sync::Mutex<()>> {
         let path = path.as_ref().to_path_buf();
         let mut locks = self.locks.lock().unwrap();
+
+        // Clean up stale entries if the map is getting large
+        if locks.len() >= MAX_LOCK_ENTRIES {
+            Self::cleanup_stale_entries(&mut locks);
+        }
+
         locks
             .entry(path)
             .or_insert_with(|| Arc::new(std::sync::Mutex::new(())))
             .clone()
     }
 
+    /// Remove lock entries that are no longer in use.
+    ///
+    /// An entry is considered stale when only the HashMap holds a reference
+    /// to it (strong_count == 1), meaning no caller is currently using the lock.
+    fn cleanup_stale_entries(
+        locks: &mut std::collections::HashMap<PathBuf, Arc<std::sync::Mutex<()>>>,
+    ) {
+        locks.retain(|_, arc| Arc::strong_count(arc) > 1);
+    }
+
+    /// Manually trigger cleanup of stale lock entries.
+    ///
+    /// This removes entries where no external reference exists (only the
+    /// manager holds the Arc). Useful for periodic maintenance.
+    pub fn cleanup(&self) {
+        let mut locks = self.locks.lock().unwrap();
+        Self::cleanup_stale_entries(&mut locks);
+    }
+
+    /// Returns the current number of lock entries in the manager.
+    pub fn lock_count(&self) -> usize {
+        self.locks.lock().unwrap().len()
+    }
+
     /// Execute an operation with both process-local and file-system locks.
     pub fn with_lock<T, F>(&self, path: impl AsRef<Path>, mode: LockMode, f: F) -> FileLockResult<T>
     where

src/cortex-resume/src/session_store.rs

@@ -13,15 +13,34 @@ use tokio::fs;
 use tokio::sync::{Mutex as AsyncMutex, RwLock};
 use tracing::{debug, info};
 
+/// Maximum number of lock entries before triggering cleanup.
+const MAX_LOCK_ENTRIES: usize = 10_000;
+
 /// Global file lock manager for session store operations.
 /// Prevents concurrent modifications to the same file within the process.
 static FILE_LOCKS: once_cell::sync::Lazy<std::sync::Mutex<HashMap<PathBuf, Arc<AsyncMutex<()>>>>> =
     once_cell::sync::Lazy::new(|| std::sync::Mutex::new(HashMap::new()));
 
+/// Remove lock entries that are no longer in use.
+///
+/// An entry is considered stale when only the HashMap holds a reference
+/// to it (strong_count == 1), meaning no caller is currently using the lock.
+fn cleanup_stale_file_locks(locks: &mut HashMap<PathBuf, Arc<AsyncMutex<()>>>) {
+    locks.retain(|_, arc| Arc::strong_count(arc) > 1);
+}
+
 /// Acquire an async lock for a specific file path.
+///
+/// Automatically cleans up stale lock entries when the map grows too large.
 fn get_file_lock(path: &Path) -> Arc<AsyncMutex<()>> {
     let canonical = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
     let mut locks = FILE_LOCKS.lock().unwrap();
+
+    // Clean up stale entries if the map is getting large
+    if locks.len() >= MAX_LOCK_ENTRIES {
+        cleanup_stale_file_locks(&mut locks);
+    }
+
     locks
         .entry(canonical)
         .or_insert_with(|| Arc::new(AsyncMutex::new(())))