claude-mpm 4.20.3__py3-none-any.whl → 5.1.8__py3-none-any.whl

claude_mpm/services/mcp_gateway/tools/kuzu_memory_service.py

@@ -199,7 +199,9 @@ class KuzuMemoryService(BaseToolAdapter):
         try:
             if action == "store":
                 result = await self.store_memory(
-                    params.get("content"), params.get("tags"), {}  # metadata
+                    params.get("content"),
+                    params.get("tags"),
+                    {},  # metadata
                 )
             elif action == "recall":
                 result = await self.recall_memories(
@@ -213,7 +215,9 @@ class KuzuMemoryService(BaseToolAdapter):
                 )
             elif action == "context":
                 result = await self.get_context(
-                    params.get("query", ""), 2, True  # depth  # include_related
+                    params.get("query", ""),
+                    2,
+                    True,  # depth  # include_related
                 )
             else:
                 return MCPToolResult(success=False, error=f"Unknown action: {action}")

claude_mpm/services/mcp_service_verifier.py

@@ -620,12 +620,15 @@ class MCPServiceVerifier:
                 return True
 
             if "claude-mpm configure" in diagnostic.fix_command:
-                # Trigger configuration update
+                # Check if services are available (read-only)
                 from .mcp_config_manager import MCPConfigManager
 
                 manager = MCPConfigManager()
-                success, _ = manager.ensure_mcp_services_configured()
-                return success
+                available, message = manager.check_mcp_services_available()
+                if not available:
+                    # Cannot auto-fix - user must install services manually
+                    self.logger.warning(f"Cannot auto-fix: {message}")
+                return available
 
         except Exception as e:
             self.logger.error(f"Auto-fix failed for {service_name}: {e}")

claude_mpm/services/memory/failure_tracker.py

@@ -29,6 +29,7 @@ Example flow:
 
 import logging
 import re
+import threading
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Dict, List, Optional, Tuple
@@ -536,6 +537,7 @@ class FailureTracker:
 
 # Singleton instance for session-level tracking
 _tracker_instance: Optional[FailureTracker] = None
+_tracker_lock = threading.Lock()
 
 
 def get_failure_tracker() -> FailureTracker:
@@ -544,13 +546,23 @@ def get_failure_tracker() -> FailureTracker:
     WHY: Session-level tracking requires a singleton to maintain state
     across multiple hook invocations during the same session.
 
+    Thread-safe implementation using double-checked locking pattern to
+    prevent race conditions during concurrent initialization.
+
     Returns:
         The FailureTracker singleton instance
     """
     global _tracker_instance
-    if _tracker_instance is None:
-        _tracker_instance = FailureTracker()
-    return _tracker_instance
+
+    # Fast path - check without lock
+    if _tracker_instance is not None:
+        return _tracker_instance
+
+    # Slow path - acquire lock and double-check
+    with _tracker_lock:
+        if _tracker_instance is None:
+            _tracker_instance = FailureTracker()
+        return _tracker_instance
 
 
 def reset_failure_tracker() -> None:
@@ -558,6 +570,9 @@ def reset_failure_tracker() -> None:
 
     WHY: Tests need to reset state between runs. Also useful for
     explicitly starting a new tracking session.
+
+    Thread-safe implementation ensures proper cleanup.
     """
     global _tracker_instance
-    _tracker_instance = None
+    with _tracker_lock:
+        _tracker_instance = None

claude_mpm/services/memory/optimizer.py

@@ -618,7 +618,7 @@ class MemoryOptimizer(LoggerMixin):
                     )
 
                 # Check for similar items
-                consolidated, consolidated_count = self._consolidate_similar_items(
+                _consolidated, consolidated_count = self._consolidate_similar_items(
                     unique_points
                 )
                 if consolidated_count > 0:

claude_mpm/services/model/model_router.py

@@ -266,7 +266,7 @@ class ModelRouter(BaseService, IModelRouter):
 
         # Route based on strategy
         if self.strategy == RoutingStrategy.CLAUDE_ONLY:
-            return await self._route_to_claude(content, task, model, **kwargs)
+            return await self._route_to_claude(content, task, model=model, **kwargs)
 
         if self.strategy in (
             RoutingStrategy.OLLAMA_ONLY,
@@ -275,13 +275,13 @@ class ModelRouter(BaseService, IModelRouter):
             return await self._route_to_ollama(
                 content,
                 task,
-                model,
+                model=model,
                 require_success=True,
                 **kwargs,
             )
 
         # AUTO strategy
-        return await self._route_auto(content, task, model, **kwargs)
+        return await self._route_auto(content, task, model=model, **kwargs)
 
     async def _route_auto(
         self,
@@ -308,7 +308,7 @@ class ModelRouter(BaseService, IModelRouter):
             response = await self._route_to_ollama(
                 content,
                 task,
-                model,
+                model=model,
                 require_success=False,
                 **kwargs,
             )
@@ -325,7 +325,7 @@ class ModelRouter(BaseService, IModelRouter):
         # Ollama unavailable or failed - fallback to Claude
         if self.fallback_enabled:
             self.log_info("Falling back to Claude")
-            return await self._route_to_claude(content, task, model, **kwargs)
+            return await self._route_to_claude(content, task, model=model, **kwargs)
         return self._create_error_response(
             task,
             model,
@@ -356,8 +356,7 @@ class ModelRouter(BaseService, IModelRouter):
         if require_success and not await self.ollama_provider.is_available():
             if self.strategy == RoutingStrategy.PRIVACY_FIRST:
                 error_msg = (
-                    "Ollama not available. Privacy mode enabled - "
-                    "not sending to cloud."
+                    "Ollama not available. Privacy mode enabled - not sending to cloud."
                 )
             else:
                 error_msg = "Ollama not available and required by configuration"
@@ -368,7 +367,7 @@ class ModelRouter(BaseService, IModelRouter):
         self._route_count["ollama"] += 1
 
         return await self.ollama_provider.analyze_content(
-            content, task, model, **kwargs
+            content, task, model=model, **kwargs
         )
 
     async def _route_to_claude(
@@ -394,7 +393,7 @@ class ModelRouter(BaseService, IModelRouter):
         self._route_count["claude"] += 1
 
         return await self.claude_provider.analyze_content(
-            content, task, model, **kwargs
+            content, task, model=model, **kwargs
         )
 
     def _create_error_response(

claude_mpm/services/monitor/daemon.py

@@ -88,11 +88,12 @@ class UnifiedMonitorDaemon:
         self.shutdown_event = threading.Event()
 
     def _get_default_pid_file(self) -> str:
-        """Get default PID file path."""
+        """Get default PID file path with port number to support multiple daemons."""
         project_root = Path.cwd()
         claude_mpm_dir = project_root / ".claude-mpm"
         claude_mpm_dir.mkdir(exist_ok=True)
-        return str(claude_mpm_dir / "monitor-daemon.pid")
+        # Include port in filename to support multiple daemon instances
+        return str(claude_mpm_dir / f"monitor-daemon-{self.port}.pid")
 
     def start(self, force_restart: bool = False) -> bool:
         """Start the unified monitor daemon.
@@ -145,16 +146,26 @@ class UnifiedMonitorDaemon:
         if self.daemon_manager.is_running():
             existing_pid = self.daemon_manager.get_pid()
             if not force_restart:
-                self.logger.warning(f"Daemon already running with PID {existing_pid}")
+                msg = f"Daemon already running on port {self.port} with PID {existing_pid}"
+                self.logger.warning(msg)
+                # If we're in subprocess mode, this is an error - we should have cleaned up
+                if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
+                    self.logger.error(
+                        f"SUBPROCESS ERROR: {msg} - This should not happen in subprocess mode!"
+                    )
                 return False
             # Force restart was already handled above
 
         # Check for our service on the port
         is_ours, pid = self.daemon_manager.is_our_service()
         if is_ours and pid and not force_restart:
-            self.logger.warning(
-                f"Our service already running on port {self.port} (PID: {pid})"
-            )
+            msg = f"Our service already running on port {self.port} (PID: {pid})"
+            self.logger.warning(msg)
+            # If we're in subprocess mode, this is an error - we should have cleaned up
+            if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
+                self.logger.error(
+                    f"SUBPROCESS ERROR: {msg} - This should not happen in subprocess mode!"
+                )
             return False
 
         # Use subprocess approach for clean daemon startup (v4.2.40)
@@ -169,20 +180,29 @@ class UnifiedMonitorDaemon:
         if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
             # We're in a subprocess started by start_daemon_subprocess
             # We need to write the PID file ourselves since parent didn't
-            self.logger.info("Running in subprocess daemon mode, writing PID file")
+            self.logger.info(f"Running in subprocess daemon mode on port {self.port}")
+            self.logger.info(f"Subprocess PID: {os.getpid()}")
+            self.logger.info(f"PID file path: {self.daemon_manager.pid_file}")
             self.daemon_manager.write_pid_file()
+            self.logger.info("PID file written successfully")
 
             # Setup signal handlers for graceful shutdown
             self._setup_signal_handlers()
+            self.logger.info("Signal handlers configured")
 
             # Start the server (this will run until shutdown)
+            self.logger.info("Starting server in subprocess mode...")
             try:
                 result = self._run_server()
                 if not result:
                     self.logger.error("Failed to start server in subprocess mode")
+                    return result
+                self.logger.info("Server started successfully in subprocess mode")
                 return result
             except Exception as e:
-                self.logger.error(f"Server startup exception in subprocess: {e}")
+                self.logger.error(
+                    f"Server startup exception in subprocess: {e}", exc_info=True
+                )
                 raise
         else:
             # Legacy fork approach (kept for compatibility but not used by default)
@@ -479,7 +499,7 @@ class UnifiedMonitorDaemon:
             except OSError:
                 if i < 9:
                     self.logger.debug(
-                        f"Port {self.port} still in use, waiting... ({i+1}/10)"
+                        f"Port {self.port} still in use, waiting... ({i + 1}/10)"
                     )
                     time.sleep(1)
                 else:

claude_mpm/services/monitor/daemon_manager.py

@@ -80,18 +80,20 @@ class DaemonManager:
         self.startup_status_file = None
 
     def _get_default_pid_file(self) -> Path:
-        """Get default PID file path."""
+        """Get default PID file path with port number to support multiple daemons."""
         project_root = Path.cwd()
         claude_mpm_dir = project_root / ".claude-mpm"
         claude_mpm_dir.mkdir(exist_ok=True)
-        return claude_mpm_dir / "monitor-daemon.pid"
+        # Include port in filename to support multiple daemon instances
+        return claude_mpm_dir / f"monitor-daemon-{self.port}.pid"
 
     def _get_default_log_file(self) -> Path:
-        """Get default log file path."""
+        """Get default log file path with port number to support multiple daemons."""
         project_root = Path.cwd()
         claude_mpm_dir = project_root / ".claude-mpm"
         claude_mpm_dir.mkdir(exist_ok=True)
-        return claude_mpm_dir / "monitor-daemon.log"
+        # Include port in filename to support multiple daemon instances
+        return claude_mpm_dir / f"monitor-daemon-{self.port}.log"
 
     def cleanup_port_conflicts(self, max_retries: int = 3) -> bool:
         """Clean up any processes using the daemon port.
@@ -471,6 +473,55 @@ class DaemonManager:
 
         return None
 
+    def _verify_daemon_health(self, max_attempts: int = 3) -> bool:
+        """Verify daemon is healthy by checking HTTP health endpoint.
+
+        Args:
+            max_attempts: Maximum number of connection attempts
+
+        Returns:
+            True if health check passes, False otherwise
+        """
+        try:
+            import requests
+
+            for attempt in range(max_attempts):
+                try:
+                    # Try to connect to health endpoint
+                    response = requests.get(
+                        f"http://{self.host}:{self.port}/health", timeout=2
+                    )
+
+                    if response.status_code == 200:
+                        self.logger.debug(
+                            f"Health check passed on attempt {attempt + 1}/{max_attempts}"
+                        )
+                        return True
+
+                    self.logger.debug(
+                        f"Health check returned status {response.status_code} on attempt {attempt + 1}/{max_attempts}"
+                    )
+
+                except requests.exceptions.RequestException as e:
+                    self.logger.debug(
+                        f"Health check attempt {attempt + 1}/{max_attempts} failed: {e}"
+                    )
+
+                # Wait before retry (except on last attempt)
+                if attempt < max_attempts - 1:
+                    time.sleep(1)
+
+            self.logger.debug(f"Health check failed after {max_attempts} attempts")
+            return False
+
+        except ImportError:
+            # requests not available, skip health check
+            self.logger.debug("requests library not available, skipping health check")
+            return True
+        except Exception as e:
+            self.logger.debug(f"Health check error: {e}")
+            return False
+
     def start_daemon(self, force_restart: bool = False) -> bool:
         """Start the daemon with automatic cleanup and retry.
 
@@ -588,36 +639,62 @@ class DaemonManager:
                 pid = process.pid
                 self.logger.info(f"Monitor subprocess started with PID {pid}")
 
-                # Wait for the subprocess to write its PID file
+                # Wait for the subprocess to write its PID file and bind to port
                 # The subprocess will write the PID file after it starts successfully
                 max_wait = 10  # seconds
                 start_time = time.time()
+                pid_file_found = False
+                port_bound = False
+
+                self.logger.debug(f"Waiting up to {max_wait}s for daemon to start...")
 
                 while time.time() - start_time < max_wait:
                     # Check if process is still running
-                    if process.poll() is not None:
-                        # Process exited
+                    returncode = process.poll()
+                    if returncode is not None:
+                        # Process exited - this is the bug we're fixing!
+                        self.logger.error(
+                            f"Monitor daemon subprocess exited prematurely with code {returncode}"
+                        )
                         self.logger.error(
-                            f"Monitor daemon exited with code {process.returncode}"
+                            f"Port {self.port} daemon failed to start. Check {self.log_file} for details."
                         )
                         return False
 
                     # Check if PID file was written
-                    if self.pid_file.exists():
+                    if not pid_file_found and self.pid_file.exists():
                         try:
                             with self.pid_file.open() as f:
                                 written_pid = int(f.read().strip())
                             if written_pid == pid:
-                                # PID file written correctly, check port
-                                if (
-                                    not self._is_port_available()
-                                ):  # Port NOT available means it's in use (good!)
-                                    self.logger.info(
-                                        f"Monitor daemon successfully started on port {self.port}"
-                                    )
-                                    return True
-                        except Exception:
-                            pass  # PID file not ready yet
+                                pid_file_found = True
+                                self.logger.debug(
+                                    f"PID file found with correct PID {pid}"
+                                )
+                        except Exception as e:
+                            self.logger.debug(f"Error reading PID file: {e}")
+
+                    # Check if port is bound (health check)
+                    if not port_bound and not self._is_port_available():
+                        # Port NOT available means it's in use (good!)
+                        port_bound = True
+                        self.logger.debug(f"Port {self.port} is now bound")
+
+                    # Success criteria: both PID file exists and port is bound
+                    if pid_file_found and port_bound:
+                        self.logger.info(
+                            f"Monitor daemon successfully started on port {self.port} (PID: {pid})"
+                        )
+                        # Additional health check: verify we can connect
+                        if self._verify_daemon_health(max_attempts=3):
+                            self.logger.info("Daemon health check passed")
+                            return True
+                        self.logger.warning(
+                            "Daemon started but health check failed - may still be initializing"
+                        )
+                        return (
+                            True  # Return success anyway if PID file and port are good
+                        )
 
                     time.sleep(0.5)
 

claude_mpm/services/monitor/server.py

@@ -203,8 +203,8 @@ class UnifiedMonitorServer:
             # Create Socket.IO server with proper ping configuration
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
-                logger=False,
-                engineio_logger=False,
+                logger=True,  # Enable to see Socket.IO events and connection lifecycle
+                engineio_logger=True,  # Enable to see Engine.IO protocol handshake details
                 ping_interval=30,  # 30 seconds ping interval (matches client expectation)
                 ping_timeout=60,  # 60 seconds ping timeout (generous for stability)
             )