claude-mpm 4.2.22__py3-none-any.whl → 4.2.24__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.22
+4.2.24

claude_mpm/cli/commands/monitor.py

@@ -91,8 +91,11 @@ class MonitorCommand(BaseCommand):
             host=host, port=port, daemon_mode=daemon_mode
         )
 
+        # Get force restart flag
+        force_restart = getattr(args, "force", False)
+        
         # Check if already running
-        if self.daemon.lifecycle.is_running():
+        if self.daemon.lifecycle.is_running() and not force_restart:
             existing_pid = self.daemon.lifecycle.get_pid()
             return CommandResult.success_result(
                 f"Unified monitor daemon already running with PID {existing_pid}",
@@ -103,8 +106,8 @@ class MonitorCommand(BaseCommand):
                 },
             )
 
-        # Start the daemon
-        if self.daemon.start():
+        # Start the daemon (with force restart if specified)
+        if self.daemon.start(force_restart=force_restart):
             # For daemon mode, verify it actually started
             if daemon_mode:
                 # Give it a moment to fully initialize

claude_mpm/services/cli/unified_dashboard_manager.py

@@ -75,7 +75,8 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         self._lock = threading.Lock()
 
     def start_dashboard(
-        self, port: int = 8765, background: bool = False, open_browser: bool = True
+        self, port: int = 8765, background: bool = False, open_browser: bool = True,
+        force_restart: bool = False
     ) -> Tuple[bool, bool]:
         """
         Start the dashboard using unified daemon.
@@ -84,30 +85,41 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
             port: Port to run dashboard on
             background: Whether to run in background mode
             open_browser: Whether to open browser automatically
+            force_restart: If True, restart existing service if it's ours
 
         Returns:
             Tuple of (success, browser_opened)
         """
         try:
-            # Check if already running
-            if self.is_dashboard_running(port):
-                self.logger.info(f"Dashboard already running on port {port}")
+            # Create daemon instance to check service status
+            daemon = UnifiedMonitorDaemon(
+                host="localhost", port=port, daemon_mode=background
+            )
+            
+            # Check if it's our service running
+            is_ours, pid = daemon.lifecycle.is_our_service("localhost")
+            
+            if is_ours and not force_restart:
+                # Our service is already running, just open browser if needed
+                self.logger.info(f"Our dashboard already running on port {port} (PID: {pid})")
                 browser_opened = False
                 if open_browser:
                     browser_opened = self.open_browser(self.get_dashboard_url(port))
                 return True, browser_opened
+            elif is_ours and force_restart:
+                self.logger.info(f"Force restarting our dashboard on port {port} (PID: {pid})")
+            elif self.is_dashboard_running(port) and not force_restart:
+                # Different service is using the port
+                self.logger.warning(f"Port {port} is in use by a different service")
+                return False, False
 
             self.logger.info(
-                f"Starting unified dashboard on port {port} (background: {background})"
+                f"Starting unified dashboard on port {port} (background: {background}, force_restart: {force_restart})"
             )
 
             if background:
-                # Start daemon in background mode
-                daemon = UnifiedMonitorDaemon(
-                    host="localhost", port=port, daemon_mode=True
-                )
-
-                success = daemon.start()
+                # Start daemon in background mode with force restart if needed
+                success = daemon.start(force_restart=force_restart)
                 if success:
                     with self._lock:
                         self._background_daemons[port] = daemon
@@ -293,7 +305,7 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         return self.port_manager.find_available_port(preferred_port)
 
     def start_server(
-        self, port: Optional[int] = None, timeout: int = 30
+        self, port: Optional[int] = None, timeout: int = 30, force_restart: bool = True
     ) -> Tuple[bool, DashboardInfo]:
         """
         Start the server (compatibility method for SocketIOManager interface).
@@ -301,6 +313,7 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         Args:
             port: Port to use (finds available if None)
             timeout: Timeout for startup
+            force_restart: If True, restart existing service if it's ours
 
         Returns:
             Tuple of (success, DashboardInfo)
@@ -308,8 +321,9 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         if port is None:
             port = self.find_available_port()
 
+        # Use force_restart to ensure we're using the latest code
         success, browser_opened = self.start_dashboard(
-            port=port, background=True, open_browser=False
+            port=port, background=True, open_browser=False, force_restart=force_restart
         )
 
         if success:

claude_mpm/services/monitor/daemon.py

@@ -81,29 +81,80 @@ class UnifiedMonitorDaemon:
         claude_mpm_dir.mkdir(exist_ok=True)
         return str(claude_mpm_dir / "monitor-daemon.pid")
 
-    def start(self) -> bool:
+    def start(self, force_restart: bool = False) -> bool:
         """Start the unified monitor daemon.
 
+        Args:
+            force_restart: If True, restart existing service if it's ours
+
         Returns:
             True if started successfully, False otherwise
         """
         try:
             if self.daemon_mode:
-                return self._start_daemon()
-            return self._start_foreground()
+                return self._start_daemon(force_restart=force_restart)
+            return self._start_foreground(force_restart=force_restart)
         except Exception as e:
             self.logger.error(f"Failed to start unified monitor daemon: {e}")
             return False
 
-    def _start_daemon(self) -> bool:
-        """Start as background daemon process."""
+    def _start_daemon(self, force_restart: bool = False) -> bool:
+        """Start as background daemon process.
+        
+        Args:
+            force_restart: If True, restart existing service if it's ours
+        """
         self.logger.info("Starting unified monitor daemon in background mode")
 
         # Check if already running
         if self.lifecycle.is_running():
             existing_pid = self.lifecycle.get_pid()
-            self.logger.warning(f"Daemon already running with PID {existing_pid}")
-            return False
+            
+            if force_restart:
+                # Check if it's our service
+                self.logger.debug(f"Checking if existing daemon (PID: {existing_pid}) is our service...")
+                is_ours, detected_pid = self.lifecycle.is_our_service(self.host)
+                
+                if is_ours:
+                    self.logger.info(f"Force restarting our existing claude-mpm monitor daemon (PID: {detected_pid or existing_pid})")
+                    # Stop the existing daemon
+                    if self.lifecycle.stop_daemon():
+                        # Wait a moment for port to be released
+                        time.sleep(2)
+                    else:
+                        self.logger.error("Failed to stop existing daemon for restart")
+                        return False
+                else:
+                    self.logger.warning(f"Port {self.port} is in use by another service (PID: {existing_pid}). Cannot force restart.")
+                    self.logger.info("To restart the claude-mpm monitor, first stop the other service or use a different port.")
+                    return False
+            else:
+                self.logger.warning(f"Daemon already running with PID {existing_pid}")
+                return False
+        
+        # Check for orphaned processes (service running but no PID file)
+        elif force_restart:
+            self.logger.debug("No PID file found, checking for orphaned claude-mpm service...")
+            is_ours, pid = self.lifecycle.is_our_service(self.host)
+            if is_ours and pid:
+                self.logger.info(f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting")
+                # Try to kill the orphaned process
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                    # Wait for it to exit
+                    for _ in range(10):
+                        try:
+                            os.kill(pid, 0)  # Check if still exists
+                            time.sleep(0.5)
+                        except ProcessLookupError:
+                            break
+                    else:
+                        # Force kill if still running
+                        os.kill(pid, signal.SIGKILL)
+                        time.sleep(1)
+                except Exception as e:
+                    self.logger.error(f"Failed to kill orphaned process: {e}")
+                    return False
         
         # Verify port is available before forking
         port_available, error_msg = self.lifecycle.verify_port_available(self.host)
@@ -133,17 +184,65 @@ class UnifiedMonitorDaemon:
             self.lifecycle._report_startup_error(f"Server startup exception: {e}")
             raise
 
-    def _start_foreground(self) -> bool:
-        """Start in foreground mode."""
+    def _start_foreground(self, force_restart: bool = False) -> bool:
+        """Start in foreground mode.
+        
+        Args:
+            force_restart: If True, restart existing service if it's ours
+        """
         self.logger.info(f"Starting unified monitor daemon on {self.host}:{self.port}")
 
         # Check if already running (check PID file even in foreground mode)
         if self.lifecycle.is_running():
             existing_pid = self.lifecycle.get_pid()
-            self.logger.warning(
-                f"Monitor daemon already running with PID {existing_pid}"
-            )
-            return False
+            
+            if force_restart:
+                # Check if it's our service
+                self.logger.debug(f"Checking if existing daemon (PID: {existing_pid}) is our service...")
+                is_ours, detected_pid = self.lifecycle.is_our_service(self.host)
+                
+                if is_ours:
+                    self.logger.info(f"Force restarting our existing claude-mpm monitor daemon (PID: {detected_pid or existing_pid})")
+                    # Stop the existing daemon
+                    if self.lifecycle.stop_daemon():
+                        # Wait a moment for port to be released
+                        time.sleep(2)
+                    else:
+                        self.logger.error("Failed to stop existing daemon for restart")
+                        return False
+                else:
+                    self.logger.warning(f"Port {self.port} is in use by another service (PID: {existing_pid}). Cannot force restart.")
+                    self.logger.info("To restart the claude-mpm monitor, first stop the other service or use a different port.")
+                    return False
+            else:
+                self.logger.warning(
+                    f"Monitor daemon already running with PID {existing_pid}"
+                )
+                return False
+        
+        # Check for orphaned processes (service running but no PID file)
+        elif force_restart:
+            self.logger.debug("No PID file found, checking for orphaned claude-mpm service...")
+            is_ours, pid = self.lifecycle.is_our_service(self.host)
+            if is_ours and pid:
+                self.logger.info(f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting")
+                # Try to kill the orphaned process
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                    # Wait for it to exit
+                    for _ in range(10):
+                        try:
+                            os.kill(pid, 0)  # Check if still exists
+                            time.sleep(0.5)
+                        except ProcessLookupError:
+                            break
+                    else:
+                        # Force kill if still running
+                        os.kill(pid, signal.SIGKILL)
+                        time.sleep(1)
+                except Exception as e:
+                    self.logger.error(f"Failed to kill orphaned process: {e}")
+                    return False
 
         # Setup signal handlers for graceful shutdown
         self._setup_signal_handlers()

claude_mpm/services/monitor/management/lifecycle.py

@@ -21,6 +21,7 @@ import tempfile
 import time
 from pathlib import Path
 from typing import Optional, Tuple
+import json
 
 from ....core.logging_config import get_logger
 
@@ -497,3 +498,184 @@ class DaemonLifecycle:
         except OSError as e:
             error_msg = f"Port {self.port} is already in use or cannot be bound: {e}"
             return False, error_msg
+    
+    def is_our_service(self, host: str = "localhost") -> Tuple[bool, Optional[int]]:
+        """Check if the service on the port is our Socket.IO service.
+        
+        This uses multiple detection methods:
+        1. Check health endpoint for service signature
+        2. Check Socket.IO namespace availability
+        3. Check process ownership if PID file exists
+        
+        Args:
+            host: Host to check
+            
+        Returns:
+            Tuple of (is_ours, pid_if_found)
+        """
+        self.logger.debug(f"Checking if service on {host}:{self.port} is ours")
+        
+        try:
+            # Method 1: Check health endpoint
+            import urllib.request
+            import urllib.error
+            
+            health_url = f"http://{host}:{self.port}/health"
+            self.logger.debug(f"Checking health endpoint: {health_url}")
+            
+            try:
+                req = urllib.request.Request(health_url)
+                req.add_header('User-Agent', 'claude-mpm-monitor')
+                
+                with urllib.request.urlopen(req, timeout=3) as response:
+                    if response.status == 200:
+                        data = json.loads(response.read().decode())
+                        self.logger.debug(f"Health endpoint response: {data}")
+                        
+                        # Check for our service signature
+                        service_name = data.get("service")
+                        if service_name == "claude-mpm-monitor":
+                            # Try to get PID from response
+                            pid = data.get("pid")
+                            if pid:
+                                self.logger.info(f"Found our claude-mpm-monitor service via health endpoint, PID: {pid}")
+                                return True, pid
+                            else:
+                                # Service is ours but no PID in response
+                                # Try to get from PID file
+                                file_pid = self.get_pid()
+                                self.logger.info(f"Found our claude-mpm-monitor service via health endpoint, PID from file: {file_pid}")
+                                return True, file_pid
+                        else:
+                            self.logger.debug(f"Service name '{service_name}' does not match 'claude-mpm-monitor'")
+                            
+            except urllib.error.URLError as e:
+                self.logger.debug(f"Health endpoint not accessible: {e}")
+            except urllib.error.HTTPError as e:
+                self.logger.debug(f"Health endpoint HTTP error: {e}")
+            except json.JSONDecodeError as e:
+                self.logger.debug(f"Health endpoint invalid JSON: {e}")
+            except Exception as e:
+                self.logger.debug(f"Health endpoint check failed: {e}")
+            
+            # Method 2: Check if PID file exists and process matches
+            pid = self.get_pid()
+            if pid:
+                self.logger.debug(f"Checking PID from file: {pid}")
+                try:
+                    # Check if process exists
+                    os.kill(pid, 0)
+                    self.logger.debug(f"Process {pid} exists")
+                    
+                    # Process exists, check if it's using our port
+                    # This requires psutil for accurate port checking
+                    try:
+                        import psutil
+                        process = psutil.Process(pid)
+                        
+                        # Check process command line for our service
+                        cmdline = ' '.join(process.cmdline())
+                        if 'claude_mpm' in cmdline or 'claude-mpm' in cmdline:
+                            if 'monitor' in cmdline:
+                                self.logger.info(f"Found our claude-mpm monitor process via PID file, PID: {pid}")
+                                return True, pid
+                        
+                        # Also check if it's listening on our port
+                        connections = process.connections()
+                        for conn in connections:
+                            if conn.laddr.port == self.port and conn.status == 'LISTEN':
+                                self.logger.info(f"Found process {pid} listening on our port {self.port}")
+                                # Double-check it's a Python process (likely ours)
+                                if 'python' in process.name().lower():
+                                    self.logger.info(f"Confirmed as Python process, assuming it's our service")
+                                    return True, pid
+                                    
+                    except ImportError:
+                        # psutil not available, but we have a PID file and process exists
+                        # Assume it's ours since we manage the PID file
+                        self.logger.info(f"Found process with our PID file: {pid}, assuming it's ours (psutil not available)")
+                        return True, pid
+                    except psutil.NoSuchProcess:
+                        self.logger.debug(f"Process {pid} no longer exists")
+                    except psutil.AccessDenied:
+                        # Can't access process info, but it exists - likely ours
+                        self.logger.info(f"Process {pid} exists but access denied, assuming it's ours")
+                        return True, pid
+                    except Exception as e:
+                        self.logger.debug(f"Error checking process {pid}: {e}")
+                        
+                except (OSError, ProcessLookupError):
+                    # Process doesn't exist
+                    self.logger.debug(f"Process {pid} does not exist")
+                    self._cleanup_stale_pid_file()
+            
+            # Method 3: Try Socket.IO connection to check namespace
+            try:
+                import socketio
+                sio_client = socketio.Client()
+                
+                # Try to connect with a short timeout
+                connected = False
+                def on_connect():
+                    nonlocal connected
+                    connected = True
+                
+                sio_client.on('connect', on_connect)
+                
+                try:
+                    sio_client.connect(f'http://{host}:{self.port}', wait_timeout=2)
+                    if connected:
+                        # Successfully connected to Socket.IO
+                        sio_client.disconnect()
+                        
+                        # Check for orphaned process (no PID file but service running)
+                        try:
+                            # Try to find process using the port
+                            import psutil
+                            for proc in psutil.process_iter(['pid', 'name']):
+                                try:
+                                    for conn in proc.connections():
+                                        if conn.laddr.port == self.port and conn.status == 'LISTEN':
+                                            # Found process listening on our port
+                                            if 'python' in proc.name().lower():
+                                                self.logger.debug(f"Found likely orphaned claude-mpm service on port {self.port}, PID: {proc.pid}")
+                                                return True, proc.pid
+                                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                                    continue
+                        except ImportError:
+                            pass
+                        
+                        # Socket.IO service exists but can't determine if it's ours
+                        self.logger.debug(f"Found Socket.IO service on port {self.port}, but cannot confirm ownership")
+                        return False, None
+                        
+                except Exception:
+                    pass
+                finally:
+                    if sio_client.connected:
+                        sio_client.disconnect()
+                        
+            except ImportError:
+                # socketio not available
+                pass
+            except Exception as e:
+                self.logger.debug(f"Error checking Socket.IO connection: {e}")
+            
+            # Method 4: Final fallback - if we have a PID file and can't definitively say it's NOT ours
+            # This handles edge cases where the health endpoint might be temporarily unavailable
+            if pid and self.pid_file.exists():
+                try:
+                    # One more check - see if process exists
+                    os.kill(pid, 0)
+                    self.logger.info(f"PID file exists with valid process {pid}, assuming it's our stale service")
+                    return True, pid
+                except (OSError, ProcessLookupError):
+                    pass
+            
+            # No service detected or not ours
+            self.logger.debug("Service not detected as ours")
+            return False, None
+            
+        except Exception as e:
+            self.logger.error(f"Error checking if service is ours: {e}", exc_info=True)
+            return False, None

claude_mpm/services/monitor/server.py

@@ -15,6 +15,7 @@ DESIGN DECISIONS:
 """
 
 import asyncio
+import os
 import threading
 import time
 from datetime import datetime
@@ -308,12 +309,23 @@ class UnifiedMonitorServer:
 
             # Health check
             async def health_check(request):
+                # Get version from VERSION file
+                version = "1.0.0"
+                try:
+                    version_file = Path(__file__).parent.parent.parent.parent.parent / "VERSION"
+                    if version_file.exists():
+                        version = version_file.read_text().strip()
+                except Exception:
+                    pass
+                
                 return web.json_response(
                     {
                         "status": "healthy",
-                        "service": "unified-monitor",
-                        "version": "1.0.0",
+                        "service": "claude-mpm-monitor",  # Important: must match what is_our_service() checks
+                        "version": version,
                         "port": self.port,
+                        "pid": os.getpid(),
+                        "uptime": int(time.time() - self.server_start_time),
                     }
                 )
 

{claude_mpm-4.2.22.dist-info → claude_mpm-4.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.22
+Version: 4.2.24
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.2.22.dist-info → claude_mpm-4.2.24.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=Ot17YPeSmtj6ZTyrKo7TK2xXA1paIoGEVSS9MGsMyHA,7
+claude_mpm/VERSION,sha256=U4vIe-sZ-5Iumq-KW3abswP9PknmnEd-RswDftmED1g,7
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=I946iCQzIIPRZVVJ8aO7lA4euiyDnNw2IX7EelAOkIE,5915
@@ -83,7 +83,7 @@ claude_mpm/cli/commands/mcp_pipx_config.py,sha256=sE62VD6Q1CcO2k1nlbIhHMfAJFQTZf
 claude_mpm/cli/commands/mcp_server_commands.py,sha256=-1G_2Y5ScTvzDd-kY8fTAao2H6FH7DnsLimleF1rVqQ,6197
 claude_mpm/cli/commands/mcp_tool_commands.py,sha256=q17GzlFT3JiLTrDqwPO2tz1-fKmPO5QU449syTnKTz4,1283
 claude_mpm/cli/commands/memory.py,sha256=Yzfs3_oiKciv3sfOoDm2lJL4M9idG7ARV3-sNw1ge_g,26186
-claude_mpm/cli/commands/monitor.py,sha256=WeUprVOIbuZuxmw4GJo54RPTnYIIJ5LgFonAymeTW7k,9442
+claude_mpm/cli/commands/monitor.py,sha256=K8TNtOsdsFgzr9VePELxFnNqZOGhL5a7XFbgOpNYq0g,9621
 claude_mpm/cli/commands/mpm_init.py,sha256=lO7N91ZHn_n18XbchUUcYoyme7L5NLcXVnhWm5F_Gq8,22367
 claude_mpm/cli/commands/mpm_init_handler.py,sha256=-pCB0XL3KipqGtnta8CC7Lg5TPMwstEhMFBcgF4aaa4,2919
 claude_mpm/cli/commands/run.py,sha256=qS3eolLiDrE8EXLQJioB6kL1ONr_l0c3OE3qMUJCqbA,43489
@@ -432,7 +432,7 @@ claude_mpm/services/cli/memory_crud_service.py,sha256=ciN9Pl_12iDAqF9zPBWOzu-iXi
 claude_mpm/services/cli/memory_output_formatter.py,sha256=nbf7VsjGvH4e9fLv9c7PzjuO9COZhbK5P2fNZ79055w,24783
 claude_mpm/services/cli/session_manager.py,sha256=rla_Stbcvt93wa9G9MCMu9UqB3FLGqlPt_eN5lQb3Gg,16599
 claude_mpm/services/cli/startup_checker.py,sha256=efhuvu8ns5G16jcQ0nQZKVddmD2AktUEdlvjNcXjAuk,12232
-claude_mpm/services/cli/unified_dashboard_manager.py,sha256=GHLDe57UI1SMW04G6E97oc-bZPnNDv4eMXrUfll2ShE,11570
+claude_mpm/services/cli/unified_dashboard_manager.py,sha256=3IRum9HH6IA4UQtTzD5l6rCngfxfqeqfTGzpKIpmZd8,12607
 claude_mpm/services/communication/__init__.py,sha256=b4qc7_Rqy4DE9q7BAUlfUZjoYG4uimAyUnE0irPcXyU,560
 claude_mpm/services/core/__init__.py,sha256=evEayLlBqJvxMZhrhuK6aagXmNrKGSj8Jm9OOxKzqvU,2195
 claude_mpm/services/core/base.py,sha256=iA-F7DgGp-FJIMvQTiHQ68RkG_k-AtUWlArJPMw6ZPk,7297
@@ -548,9 +548,9 @@ claude_mpm/services/memory/cache/__init__.py,sha256=6M6-P8ParyxX8vOgp_IxHgLMvacr
 claude_mpm/services/memory/cache/shared_prompt_cache.py,sha256=crnYPUT8zcS7TvoE1vW7pyaf4T77N5rJ1wUf_YQ2vvo,28704
 claude_mpm/services/memory/cache/simple_cache.py,sha256=qsTjbcsPxj-kNfaod9VN_uE5NioIwpfkUin_mMVUJCg,10218
 claude_mpm/services/monitor/__init__.py,sha256=X7gxSLUm9Fg_zEsX6LtCHP2ipF0qj6Emkun20h2So7g,745
-claude_mpm/services/monitor/daemon.py,sha256=oFMDnMZABAqKEuuj62W2gmDSxUSr0jHflzddMVfXz8k,16739
+claude_mpm/services/monitor/daemon.py,sha256=9Cllm-jtVA85_qX1Z3TF-OwB5QZDzSfIvAcKhVQ65G8,21829
 claude_mpm/services/monitor/event_emitter.py,sha256=JzRLNg8PUJ5s3ulNnq_D4yqCPItvidJzu8DmFxriieQ,12224
-claude_mpm/services/monitor/server.py,sha256=ELo1CLucGAiXLh7iSkwM82nCCwE_ANgqd5sMG0TwUY0,27899
+claude_mpm/services/monitor/server.py,sha256=2-xLo14qFBZf5MDYwBxBhTrFCNnbu3tOS3eEu8vyddc,28476
 claude_mpm/services/monitor/handlers/__init__.py,sha256=jgPIf4IJVERm_tAeD9834tfx9IcxtlHj5r9rhEWpkfM,701
 claude_mpm/services/monitor/handlers/code_analysis.py,sha256=mHyI27Wp6WVmUBc0m0i991ogyFZBTvkrfR7Kf3EAk5U,11474
 claude_mpm/services/monitor/handlers/dashboard.py,sha256=uGBhb-6RG6u4WLipUXgdx7RCW-vb_qek5dIfHIwAC7o,9805
@@ -558,7 +558,7 @@ claude_mpm/services/monitor/handlers/file.py,sha256=p3C4wffl0GIcN00b-KkrmZ8F-Amd
 claude_mpm/services/monitor/handlers/hooks.py,sha256=dlrmyFu8WChlvn6-sND9DLjSbm5nrMfNZrAgoWN-2No,17582
 claude_mpm/services/monitor/management/__init__.py,sha256=mxaEFRgvvgV85gUpXu_DsnHtywihdP14EisvISAVZuQ,525
 claude_mpm/services/monitor/management/health.py,sha256=Wm92Cli_4cWD6B89KX_CdpAvvevuEaGB8Ah59ILhFww,3772
-claude_mpm/services/monitor/management/lifecycle.py,sha256=-KuTXEkpoZQmqVvYE2q7EmwpezY4ZM5Yvp71cWYD93Q,17667
+claude_mpm/services/monitor/management/lifecycle.py,sha256=EClf8CK-kCLVb2iRo9uiGI2CAHFrii1Qe1i8xuWnhG4,27037
 claude_mpm/services/project/__init__.py,sha256=IUclN1L7ChHCNya7PJiVxu4nttxsrj3WRIpwyA1A_hw,512
 claude_mpm/services/project/analyzer.py,sha256=VHlLrP8-S5gr12w4Yzs7-6d7LWdJKISHPCFSG7SDiQU,38434
 claude_mpm/services/project/analyzer_refactored.py,sha256=USYEdPAhSoGPqZCpaT89Dw6ElFW_L1yXSURheQjAhLA,18243
@@ -639,9 +639,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=zgiwLqh_17WxHpySvUPH65pb4bzIeUGOAYUJ
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=3Lo6LK-Mw9IdnL_bd3zl_R6FkgSVDYKUUM7EeVVD3jc,20865
 claude_mpm/validation/frontmatter_validator.py,sha256=u8g4Eyd_9O6ugj7Un47oSGh3kqv4wMkuks2i_CtWRvM,7028
-claude_mpm-4.2.22.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.2.22.dist-info/METADATA,sha256=hPxeNHmoQ1VlgLWWOaox9vJ5hTTpODq2O67IhCUbt5g,14451
-claude_mpm-4.2.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.2.22.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.2.22.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.2.22.dist-info/RECORD,,
+claude_mpm-4.2.24.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.2.24.dist-info/METADATA,sha256=gBePVzfdnH07tGtxu8dnaQwimTu90EqPI0hcpdIZnjM,14451
+claude_mpm-4.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.2.24.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.2.24.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.2.24.dist-info/RECORD,,