claude-mpm 4.2.11__tar.gz → 4.2.13__tar.gz

claude_mpm-4.2.13/BUILD_NUMBER

@@ -0,0 +1 @@
+342

{claude_mpm-4.2.11 → claude_mpm-4.2.13}/PKG-INFO

@@ -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.13/VERSION

@@ -0,0 +1 @@
+4.2.13

{claude_mpm-4.2.11 → claude_mpm-4.2.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.2.11"
+version = "4.2.13"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -248,7 +248,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.2.11"
+version = "4.2.13"
 version_files = [
     "VERSION",
     "src/claude_mpm/VERSION",

claude_mpm-4.2.13/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.2.13

{claude_mpm-4.2.11 → claude_mpm-4.2.13}/src/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-4.2.11 → claude_mpm-4.2.13}/src/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-4.2.13/src/claude_mpm/commands/mpm-agents.md

@@ -0,0 +1,48 @@
+# Show available agents and their versions
+
+Show all available Claude MPM agents with their versions and deployment status.
+
+## 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-4.2.11 → claude_mpm-4.2.13}/src/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-4.2.11 → claude_mpm-4.2.13}/src/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-4.2.11 → claude_mpm-4.2.13}/src/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.