claude-mpm 4.2.11__py3-none-any.whl → 4.2.13__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.11
+4.2.13

claude_mpm/cli/commands/monitor.py

@@ -70,10 +70,20 @@ class MonitorCommand(BaseCommand):
         if port is None:
             port = 8765  # Default to 8765 for unified monitor
         host = getattr(args, "host", "localhost")
-        daemon_mode = getattr(args, "daemon", False)  # Default to foreground
 
+        # Check for explicit foreground flag first, then background flag
+        # Default to daemon/background mode if neither specified
+        if getattr(args, "foreground", False):
+            daemon_mode = False
+        elif getattr(args, "background", None) is not None:
+            daemon_mode = getattr(args, "background", False)
+        else:
+            # Default to daemon/background mode
+            daemon_mode = True
+
+        mode_str = "background/daemon" if daemon_mode else "foreground"
         self.logger.info(
-            f"Starting unified monitor daemon on {host}:{port} (daemon: {daemon_mode})"
+            f"Starting unified monitor daemon on {host}:{port} (mode: {mode_str})"
         )
 
         # Create unified monitor daemon
@@ -95,9 +105,10 @@ class MonitorCommand(BaseCommand):
 
         # Start the daemon
         if self.daemon.start():
+            mode_info = " in background" if daemon_mode else " in foreground"
             return CommandResult.success_result(
-                f"Unified monitor daemon started on {host}:{port}",
-                data={"url": f"http://{host}:{port}", "port": port},
+                f"Unified monitor daemon started on {host}:{port}{mode_info}",
+                data={"url": f"http://{host}:{port}", "port": port, "mode": mode_str},
             )
         return CommandResult.error_result("Failed to start unified monitor daemon")
 
@@ -111,8 +122,8 @@ class MonitorCommand(BaseCommand):
         if not daemon.lifecycle.is_running():
             return CommandResult.success_result("No unified monitor daemon running")
 
-        # Stop the daemon
-        if daemon.stop():
+        # Stop the daemon by PID (works for both daemon and foreground mode)
+        if daemon.lifecycle.stop_daemon():
             return CommandResult.success_result("Unified monitor daemon stopped")
         return CommandResult.error_result("Failed to stop unified monitor daemon")
 

claude_mpm/cli/parsers/monitor_parser.py

@@ -58,8 +58,18 @@ def add_monitor_subparser(subparsers) -> argparse.ArgumentParser:
         default=8766,
         help="Dashboard port (default: 8766)",
     )
-    start_monitor_parser.add_argument(
-        "--background", action="store_true", help="Run server in background"
+    # Add mutually exclusive group for foreground/background modes
+    mode_group = start_monitor_parser.add_mutually_exclusive_group()
+    mode_group.add_argument(
+        "--foreground",
+        action="store_true",
+        help="Run server in foreground mode (blocks terminal)",
+    )
+    mode_group.add_argument(
+        "--background",
+        action="store_true",
+        default=None,  # None allows us to detect when not specified
+        help="Run server in background/daemon mode (default behavior)",
     )
     start_monitor_parser.add_argument(
         "--force",

claude_mpm/commands/mpm-agents.md

@@ -2,11 +2,47 @@
 
 Show all available Claude MPM agents with their versions and deployment status.
 
-This command displays:
-- Agent names and descriptions
-- Version information
-- Tool availability
-- Model preferences
-- Deployment status
-
-Usage: /mpm-agents
+## Usage
+
+```
+/mpm-agents
+```
+
+## Description
+
+This command lists all available Claude MPM agents, including both built-in agents and any custom agents you've created. It shows their current deployment status, version information, and capabilities.
+
+## What This Command Does
+
+When you run `/mpm-agents`, I will:
+
+1. **List Available Agents**: Run `claude-mpm agents list` to show all agents
+2. **Display Agent Information**:
+   - Agent names and IDs
+   - Brief descriptions
+   - Model preferences (opus, sonnet, haiku)
+   - Tool availability
+   - Version information
+   - Deployment status
+
+## Output Example
+
+The command displays agents in a formatted table showing:
+- Agent name and description
+- Version and model preference
+- Tools available to the agent
+- Current deployment status
+
+## Implementation
+
+To show available agents, I'll execute:
+```bash
+claude-mpm agents list --deployed
+```
+
+This will display all deployed agents that are currently available for use.
+
+Alternatively, you can use these variations:
+- `claude-mpm agents list --system` - Show system agents
+- `claude-mpm agents list --by-tier` - Group agents by precedence tier
+- `claude-mpm agents list --all` - Show all agents including undeployed

claude_mpm/services/monitor/daemon.py

@@ -103,6 +103,9 @@ class UnifiedMonitorDaemon:
             self.logger.warning(f"Daemon already running with PID {existing_pid}")
             return False
 
+        # Wait for any pre-warming threads to complete before forking
+        self._wait_for_prewarm_completion()
+
         # Daemonize the process
         success = self.lifecycle.daemonize()
         if not success:
@@ -115,9 +118,20 @@ class UnifiedMonitorDaemon:
         """Start in foreground mode."""
         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
+
         # Setup signal handlers for graceful shutdown
         self._setup_signal_handlers()
 
+        # Write PID file for foreground mode too (so other processes can detect it)
+        self.lifecycle.write_pid_file()
+
         # Start the server
         return self._run_server()
 
@@ -170,17 +184,29 @@ class UnifiedMonitorDaemon:
             self.running = False
             self.shutdown_event.set()
 
-            # Stop server
+            # Stop server with proper cleanup
             if self.server:
+                self.logger.debug("Initiating server shutdown...")
                 self.server.stop()
+                # Give asyncio loops adequate time to cleanup properly
+                # This is critical to prevent kqueue errors
+                time.sleep(2.0)
+                self.server = None
 
             # Stop health monitoring
             if self.health_monitor:
+                self.logger.debug("Stopping health monitor...")
                 self.health_monitor.stop()
+                self.health_monitor = None
 
-            # Cleanup daemon files
-            if self.daemon_mode:
-                self.lifecycle.cleanup()
+            # Clean up any asyncio resources
+            self._cleanup_asyncio_resources()
+
+            # Give a final moment for OS-level cleanup
+            time.sleep(0.5)
+
+            # Cleanup daemon files (always cleanup PID file)
+            self.lifecycle.cleanup()
 
             self.logger.info("Unified monitor daemon stopped")
             return True
@@ -201,8 +227,10 @@ class UnifiedMonitorDaemon:
         if not self.stop():
             return False
 
-        # Wait a moment
-        time.sleep(2)
+        # Wait longer for port to be released properly
+        # This is needed because the daemon process may take time to fully cleanup
+        self.logger.info("Waiting for port to be fully released...")
+        time.sleep(3)
 
         # Start again
         return self.start()
@@ -213,12 +241,19 @@ class UnifiedMonitorDaemon:
         Returns:
             Dictionary with status information
         """
-        is_running = self.lifecycle.is_running() if self.daemon_mode else self.running
-        pid = self.lifecycle.get_pid() if self.daemon_mode else os.getpid()
+        # Always check the PID file to see if a daemon is running
+        # This ensures we detect daemons started by other processes
+        is_running = self.lifecycle.is_running()
+        pid = self.lifecycle.get_pid()
+
+        # If no PID file exists but we're running in the current process
+        if not is_running and self.running:
+            is_running = True
+            pid = os.getpid()
 
         status = {
             "running": is_running,
-            "pid": pid,
+            "pid": pid if is_running else None,
             "host": self.host,
             "port": self.port,
             "daemon_mode": self.daemon_mode,
@@ -246,11 +281,98 @@ class UnifiedMonitorDaemon:
     def _cleanup(self):
         """Cleanup resources."""
         try:
+            # Stop server first with proper cleanup
             if self.server:
+                self.logger.debug("Stopping server and cleaning up event loops...")
                 self.server.stop()
+                # Give the server more time to cleanup event loops properly
+                # This is critical to prevent kqueue errors
+                time.sleep(1.5)
+                self.server = None
 
+            # Then stop health monitor
             if self.health_monitor:
+                self.logger.debug("Stopping health monitor...")
                 self.health_monitor.stop()
+                self.health_monitor = None
+
+            # Ensure PID file is removed
+            if not self.daemon_mode:
+                # In foreground mode, make sure we cleanup the PID file
+                self.lifecycle.cleanup()
+
+            # Clean up any remaining asyncio resources in the main thread
+            self._cleanup_asyncio_resources()
+
+            # Clear any remaining references
+            self.shutdown_event.clear()
+
+            self.logger.debug("Cleanup completed successfully")
 
         except Exception as e:
             self.logger.error(f"Error during cleanup: {e}")
+
+    def _cleanup_asyncio_resources(self):
+        """Clean up any asyncio resources in the current thread."""
+        try:
+            import asyncio
+
+            # Try to get the current event loop
+            try:
+                loop = asyncio.get_event_loop()
+                if loop and not loop.is_closed():
+                    # Cancel any pending tasks
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+
+                    # Stop and close the loop
+                    if loop.is_running():
+                        loop.stop()
+
+                    # Clear the event loop from the thread
+                    asyncio.set_event_loop(None)
+
+                    # Close the loop
+                    loop.close()
+
+            except RuntimeError:
+                # No event loop in current thread, that's fine
+                pass
+
+        except Exception as e:
+            self.logger.debug(f"Error cleaning up asyncio resources: {e}")
+
+    def _wait_for_prewarm_completion(self, timeout: float = 5.0):
+        """Wait for MCP pre-warming threads to complete before forking.
+
+        This prevents inherited threads and event loops in the forked process.
+        """
+        try:
+            import threading
+            import time
+
+            start_time = time.time()
+
+            # Get all non-daemon threads (pre-warm threads are daemon threads)
+            # but we still want to give them a moment to complete
+            active_threads = [
+                t
+                for t in threading.enumerate()
+                if t.is_alive() and t != threading.current_thread()
+            ]
+
+            if active_threads:
+                self.logger.debug(
+                    f"Waiting for {len(active_threads)} threads to complete"
+                )
+
+                # Wait briefly for threads to complete
+                wait_time = min(timeout, 2.0)  # Max 2 seconds for daemon threads
+                time.sleep(wait_time)
+
+                elapsed = time.time() - start_time
+                self.logger.debug(f"Waited {elapsed:.2f}s for thread completion")
+
+        except Exception as e:
+            self.logger.debug(f"Error waiting for threads: {e}")

claude_mpm/services/monitor/event_emitter.py

@@ -251,20 +251,75 @@ class AsyncEventEmitter:
         }
 
     async def close(self):
-        """Clean up resources."""
+        """Clean up resources with proper order and timing."""
         try:
-            if self._http_session:
-                await self._http_session.close()
+            # Cancel batch processor if running
+            if self._batch_processor_task and not self._batch_processor_task.done():
+                self._batch_processor_task.cancel()
+                try:
+                    await self._batch_processor_task
+                except asyncio.CancelledError:
+                    pass
+                except Exception as e:
+                    self.logger.debug(f"Error cancelling batch processor: {e}")
+                finally:
+                    self._batch_processor_task = None
+
+            # Clear Socket.IO server references first
+            # This prevents any new events from being emitted
+            self._socketio_servers.clear()
 
+            # Close HTTP session (must be done before connector)
+            if self._http_session:
+                try:
+                    # Cancel any pending requests
+                    if (
+                        hasattr(self._http_session, "_connector")
+                        and self._http_session._connector
+                    ):
+                        # Give ongoing requests a moment to complete
+                        await asyncio.sleep(0.1)
+
+                    # Close the session
+                    await self._http_session.close()
+
+                    # CRITICAL: Wait for session to fully close
+                    # This prevents the "I/O operation on closed kqueue" error
+                    await asyncio.sleep(0.25)
+
+                except Exception as e:
+                    self.logger.debug(f"Error closing HTTP session: {e}")
+                finally:
+                    self._http_session = None
+
+            # Then close the connector (after session is fully closed)
             if self._http_connector:
-                await self._http_connector.close()
+                try:
+                    # Close the connector
+                    await self._http_connector.close()
 
-            self._socketio_servers.clear()
+                    # Give the connector adequate time to close all connections
+                    # This is critical for preventing kqueue errors
+                    await asyncio.sleep(0.5)
+
+                except Exception as e:
+                    self.logger.debug(f"Error closing HTTP connector: {e}")
+                finally:
+                    self._http_connector = None
 
-            self.logger.info("AsyncEventEmitter closed")
+            # Reset singleton instance
+            AsyncEventEmitter._instance = None
+
+            self.logger.info("AsyncEventEmitter closed successfully")
 
         except Exception as e:
             self.logger.error(f"Error closing AsyncEventEmitter: {e}")
+        finally:
+            # Ensure references are cleared even if errors occur
+            self._http_session = None
+            self._http_connector = None
+            self._socketio_servers.clear()
+            AsyncEventEmitter._instance = None
 
 
 # Global instance for easy access
@@ -277,3 +332,11 @@ async def get_event_emitter() -> AsyncEventEmitter:
     if _global_emitter is None:
         _global_emitter = await AsyncEventEmitter.get_instance()
     return _global_emitter
+
+
+async def cleanup_event_emitter():
+    """Clean up the global event emitter instance."""
+    global _global_emitter
+    if _global_emitter is not None:
+        await _global_emitter.close()
+        _global_emitter = None

claude_mpm/services/monitor/management/lifecycle.py

@@ -48,6 +48,9 @@ class DaemonLifecycle:
             True if daemonization successful, False otherwise
         """
         try:
+            # Clean up any existing asyncio event loops before forking
+            self._cleanup_event_loops()
+
             # First fork
             pid = os.fork()
             if pid > 0:
@@ -76,7 +79,7 @@ class DaemonLifecycle:
         self._redirect_streams()
 
         # Write PID file
-        self._write_pid_file()
+        self.write_pid_file()
 
         # Setup signal handlers
         self._setup_signal_handlers()
@@ -110,7 +113,7 @@ class DaemonLifecycle:
         except Exception as e:
             self.logger.error(f"Error redirecting streams: {e}")
 
-    def _write_pid_file(self):
+    def write_pid_file(self):
         """Write PID to PID file."""
         try:
             # Ensure parent directory exists
@@ -259,6 +262,43 @@ class DaemonLifecycle:
         except Exception as e:
             self.logger.error(f"Error removing stale PID file: {e}")
 
+    def _cleanup_event_loops(self):
+        """Clean up any existing asyncio event loops before forking.
+
+        This prevents the 'I/O operation on closed kqueue object' error
+        that occurs when forked processes inherit event loops.
+        """
+        try:
+            import asyncio
+            import gc
+
+            # Try to get the current event loop
+            try:
+                loop = asyncio.get_event_loop()
+                if loop and loop.is_running():
+                    # Can't close a running loop, but we can stop it
+                    loop.stop()
+                    self.logger.debug("Stopped running event loop before fork")
+                elif loop:
+                    # Close the loop if it exists and is not running
+                    loop.close()
+                    self.logger.debug("Closed event loop before fork")
+            except RuntimeError:
+                # No event loop in current thread
+                pass
+
+            # Clear the event loop policy to ensure clean state
+            asyncio.set_event_loop(None)
+
+            # Force garbage collection to clean up any loop resources
+            gc.collect()
+
+        except ImportError:
+            # asyncio not available (unlikely but handle it)
+            pass
+        except Exception as e:
+            self.logger.debug(f"Error cleaning up event loops before fork: {e}")
+
     def get_status(self) -> dict:
         """Get daemon status information.
 

claude_mpm/services/monitor/server.py

@@ -112,19 +112,61 @@ class UnifiedMonitorServer:
 
     def _run_server(self):
         """Run the server in its own event loop."""
+        loop = None
         try:
             # Create new event loop for this thread
-            self.loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self.loop)
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self.loop = loop
 
             # Run the async server
-            self.loop.run_until_complete(self._start_async_server())
+            loop.run_until_complete(self._start_async_server())
 
         except Exception as e:
             self.logger.error(f"Error in server thread: {e}")
         finally:
-            if self.loop:
-                self.loop.close()
+            # Always ensure loop cleanup happens
+            if loop is not None:
+                try:
+                    # Cancel all pending tasks first
+                    self._cancel_all_tasks(loop)
+
+                    # Give tasks a moment to cancel gracefully
+                    if not loop.is_closed():
+                        try:
+                            loop.run_until_complete(asyncio.sleep(0.1))
+                        except RuntimeError:
+                            # Loop might be stopped already, that's ok
+                            pass
+
+                except Exception as e:
+                    self.logger.debug(f"Error during task cancellation: {e}")
+                finally:
+                    try:
+                        # Clear the loop reference from the instance first
+                        self.loop = None
+
+                        # Stop the loop if it's still running
+                        if loop.is_running():
+                            loop.stop()
+
+                        # CRITICAL: Wait a moment for the loop to stop
+                        import time
+
+                        time.sleep(0.1)
+
+                        # Clear the event loop from the thread BEFORE closing
+                        # This prevents other code from accidentally using it
+                        asyncio.set_event_loop(None)
+
+                        # Now close the loop - this is critical to prevent the kqueue error
+                        if not loop.is_closed():
+                            loop.close()
+                            # Wait for the close to complete
+                            time.sleep(0.05)
+
+                    except Exception as e:
+                        self.logger.debug(f"Error during event loop cleanup: {e}")
 
     async def _start_async_server(self):
         """Start the async server components."""
@@ -392,12 +434,42 @@ class UnifiedMonitorServer:
         try:
             self.logger.info("Stopping unified monitor server")
 
+            # Signal shutdown first
             self.running = False
 
-            # Wait for server thread to finish
+            # If we have a loop, schedule the cleanup
+            if self.loop and not self.loop.is_closed():
+                try:
+                    # Use call_soon_threadsafe to schedule cleanup from another thread
+                    future = asyncio.run_coroutine_threadsafe(
+                        self._graceful_shutdown(), self.loop
+                    )
+                    # Wait for cleanup to complete (with timeout)
+                    future.result(timeout=3)
+                except Exception as e:
+                    self.logger.debug(f"Error during graceful shutdown: {e}")
+
+            # Wait for server thread to finish with a reasonable timeout
             if self.server_thread and self.server_thread.is_alive():
                 self.server_thread.join(timeout=5)
 
+                # If thread is still alive after timeout, log a warning
+                if self.server_thread.is_alive():
+                    self.logger.warning("Server thread did not stop within timeout")
+
+            # Clear all references to help with cleanup
+            self.server_thread = None
+            self.app = None
+            self.sio = None
+            self.runner = None
+            self.site = None
+            self.event_emitter = None
+
+            # Give the system a moment to cleanup resources
+            import time
+
+            time.sleep(0.2)
+
             self.logger.info("Unified monitor server stopped")
 
         except Exception as e:
@@ -406,20 +478,55 @@ class UnifiedMonitorServer:
     async def _cleanup_async(self):
         """Cleanup async resources."""
         try:
+            # Close the Socket.IO server first to stop accepting new connections
+            if self.sio:
+                try:
+                    await self.sio.shutdown()
+                    self.logger.debug("Socket.IO shutdown complete")
+                except Exception as e:
+                    self.logger.debug(f"Error shutting down Socket.IO: {e}")
+                finally:
+                    self.sio = None
+
             # Cleanup event emitter
             if self.event_emitter:
                 try:
-                    self.event_emitter.unregister_socketio_server(self.sio)
-                    await self.event_emitter.close()
+                    if self.sio:
+                        self.event_emitter.unregister_socketio_server(self.sio)
+
+                    # Use the global cleanup function to ensure proper cleanup
+                    from .event_emitter import cleanup_event_emitter
+
+                    await cleanup_event_emitter()
+
                     self.logger.info("Event emitter cleaned up")
                 except Exception as e:
                     self.logger.warning(f"Error cleaning up event emitter: {e}")
+                finally:
+                    self.event_emitter = None
 
+            # Stop the site (must be done before runner cleanup)
             if self.site:
-                await self.site.stop()
+                try:
+                    await self.site.stop()
+                    self.logger.debug("Site stopped")
+                except Exception as e:
+                    self.logger.debug(f"Error stopping site: {e}")
+                finally:
+                    self.site = None
 
+            # Cleanup the runner (after site is stopped)
             if self.runner:
-                await self.runner.cleanup()
+                try:
+                    await self.runner.cleanup()
+                    self.logger.debug("Runner cleaned up")
+                except Exception as e:
+                    self.logger.debug(f"Error cleaning up runner: {e}")
+                finally:
+                    self.runner = None
+
+            # Clear app reference
+            self.app = None
 
         except Exception as e:
             self.logger.error(f"Error during async cleanup: {e}")
@@ -440,3 +547,50 @@ class UnifiedMonitorServer:
                 "hooks": self.hook_handler is not None,
             },
         }
+
+    def _cancel_all_tasks(self, loop=None):
+        """Cancel all pending tasks in the event loop."""
+        if loop is None:
+            loop = self.loop
+
+        if not loop or loop.is_closed():
+            return
+
+        try:
+            # Get all tasks in the loop
+            pending = asyncio.all_tasks(loop)
+
+            # Count tasks to cancel
+            tasks_to_cancel = [task for task in pending if not task.done()]
+
+            if tasks_to_cancel:
+                # Cancel each task
+                for task in tasks_to_cancel:
+                    task.cancel()
+
+                # Wait for all tasks to complete cancellation
+                gather = asyncio.gather(*tasks_to_cancel, return_exceptions=True)
+                try:
+                    loop.run_until_complete(gather)
+                except Exception:
+                    # Some tasks might fail to cancel, that's ok
+                    pass
+
+                self.logger.debug(f"Cancelled {len(tasks_to_cancel)} pending tasks")
+        except Exception as e:
+            self.logger.debug(f"Error cancelling tasks: {e}")
+
+    async def _graceful_shutdown(self):
+        """Perform graceful shutdown of async resources."""
+        try:
+            # Stop accepting new connections
+            self.running = False
+
+            # Give ongoing operations a moment to complete
+            await asyncio.sleep(0.5)
+
+            # Then cleanup resources
+            await self._cleanup_async()
+
+        except Exception as e:
+            self.logger.debug(f"Error in graceful shutdown: {e}")

{claude_mpm-4.2.11.dist-info → claude_mpm-4.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.11
+Version: 4.2.13
 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.11.dist-info → claude_mpm-4.2.13.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=cd55Cs9g014dKFhr97AzpoJW-fW8NPYxthFqB5LQaw8,7
+claude_mpm/VERSION,sha256=5mfyStzIK-4pnKftSypHjTQDTxKee3RKFk0VR8PFewQ,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=G6bFgiEvV5nE_bl1C3KnxmZXLfSvIR6UPwYTYR3CLFg,6769
+claude_mpm/cli/commands/monitor.py,sha256=wdbQ-xMVvRNo0X64nZaweMG13_P8WErRZP3AKT02Hjs,7365
 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
@@ -100,7 +100,7 @@ claude_mpm/cli/parsers/dashboard_parser.py,sha256=JBCM6v_iZhADr_Fwtk_d3up9AOod1a
 claude_mpm/cli/parsers/debug_parser.py,sha256=F7MZdmiXiPfiIPMv21ZUqB2cMT8Ho1LDmpbvCXODLbY,9846
 claude_mpm/cli/parsers/mcp_parser.py,sha256=zW4wClYOGf_o8yRediJkQRxgta2RI6S3IG_QDgAkp-k,5992
 claude_mpm/cli/parsers/memory_parser.py,sha256=ZwCDxJEgp-w03L-1tZsWTgisiwamP42s424bA5bvDJc,4760
-claude_mpm/cli/parsers/monitor_parser.py,sha256=Go78VOFQCts2fouv33tKfd303w0mVPpJiuBbRBGK5x0,4525
+claude_mpm/cli/parsers/monitor_parser.py,sha256=PeoznSi_5Bw6THK_Espl8M20o6dKvvBSmFzAbovkaFQ,4920
 claude_mpm/cli/parsers/mpm_init_parser.py,sha256=PxAydGDwTmgi0lu-cQHLnk4286EBzK84StcT8Msvk0I,4791
 claude_mpm/cli/parsers/run_parser.py,sha256=bkVqtQDl0y0mQi6Ue8mSXNggUuPfXlywgyXLCOPccXg,4750
 claude_mpm/cli/parsers/tickets_parser.py,sha256=FYl-VNH7PrZzfZUCcjnf6F7g6JXnL8YDxwrmR5svIcg,6966
@@ -114,7 +114,7 @@ claude_mpm/cli_module/args.py,sha256=50_Y3AgMNeidtPjQ5-WZ1o-5Y7G2GAGQwMmllYjVScE
 claude_mpm/cli_module/commands.py,sha256=zZmjP4J19i9PNMA7gCI5Dl--R1u_H4sCt5ZtOadZkY4,7013
 claude_mpm/cli_module/migration_example.py,sha256=DtQ59RyoBD6r8FIfrjKXCQ8-xnUiOqP5McBiS6_W1Qc,5183
 claude_mpm/commands/__init__.py,sha256=paX5Ub5-UmRgiQ8UgKWIKwU2-RjLu67OmNJND-fVtjg,588
-claude_mpm/commands/mpm-agents.md,sha256=MxFYlIhvtsKwtUdGJROKTr2So-izaWGjwRkf5seSqXM,280
+claude_mpm/commands/mpm-agents.md,sha256=JnYPJ-eWvIEEtiCB6iPu182P2xDBRvU3ArVXQ7h32kU,1341
 claude_mpm/commands/mpm-config.md,sha256=F-9kKUC30gT6QXvOr5OTpYOq6L97iA2-SXVGxXjyF8M,547
 claude_mpm/commands/mpm-doctor.md,sha256=ut5LhFKVRw-2ecjMSPsnaTiRuFXa6Q9t-Wgl3CCnQvk,590
 claude_mpm/commands/mpm-help.md,sha256=gUMhJ1aTWyNeNMLZJeDJMN2sPuL-ugUFalmrNDEP5bI,282
@@ -530,16 +530,16 @@ 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=YRwAZrunZ1jE-P61gNCkFLEys7mTkJLGBxUIH8H6upU,7830
-claude_mpm/services/monitor/event_emitter.py,sha256=D9o38lOFkzJx40RE0igvFVdAi1w5WqV_09Rz7nCjWdI,9609
-claude_mpm/services/monitor/server.py,sha256=i2mynduUMNAXU0h_SSz-cx7LaBaLrkVPgtGvKXGhQFE,16008
+claude_mpm/services/monitor/daemon.py,sha256=9PyhEXpMUJ1LBmZdoLwzQmfjdCnXn8GeErywBnMScoY,12588
+claude_mpm/services/monitor/event_emitter.py,sha256=JzRLNg8PUJ5s3ulNnq_D4yqCPItvidJzu8DmFxriieQ,12224
+claude_mpm/services/monitor/server.py,sha256=fuefcZVqjEupyIKun1ElPw2mlEm2frfqh1iLcnB3af4,21911
 claude_mpm/services/monitor/handlers/__init__.py,sha256=rxPCb1jc4v0-ODRK4tTzO_IxWLlaG0d6ghF8yJgVvxw,656
 claude_mpm/services/monitor/handlers/code_analysis.py,sha256=mHyI27Wp6WVmUBc0m0i991ogyFZBTvkrfR7Kf3EAk5U,11474
 claude_mpm/services/monitor/handlers/dashboard.py,sha256=uGBhb-6RG6u4WLipUXgdx7RCW-vb_qek5dIfHIwAC7o,9805
 claude_mpm/services/monitor/handlers/hooks.py,sha256=s9CVlDLd-onH6WCOPeN06UjpEYVfuGjHw_icz220K_M,16533
 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=T7-NF1vous250B7gkEEuaKzzxkhnhn4M3vlXRadbOjE,9082
+claude_mpm/services/monitor/management/lifecycle.py,sha256=Cahpc1-R09ihDYVWiMI9wnv-Qw20cNhHHcJyxZ9JcBo,10575
 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
@@ -620,9 +620,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.11.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.2.11.dist-info/METADATA,sha256=bOfT109kHO6oXl8vnKSjnAw59js6kRdhHUpG5-2f3pg,13777
-claude_mpm-4.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.2.11.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.2.11.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.2.11.dist-info/RECORD,,
+claude_mpm-4.2.13.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.2.13.dist-info/METADATA,sha256=8KwBn_hYIaHTcm94JC1lyY29sy8K2_PwOtmW_8PMbn4,13777
+claude_mpm-4.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.2.13.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.2.13.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.2.13.dist-info/RECORD,,