claude-mpm 5.1.9__py3-none-any.whl → 5.4.14__py3-none-any.whl

claude_mpm/services/command_deployment_service.py

@@ -23,8 +23,7 @@ class CommandDeploymentService(BaseService):
     DEPRECATED_COMMANDS = [
         "mpm-agents.md",  # Replaced by mpm-agents-list.md
         "mpm-auto-configure.md",  # Replaced by mpm-agents-auto-configure.md
-        "mpm-config.md",  # Replaced by mpm-config-view.md
-        "mpm-organize.md",  # Replaced by mpm-ticket-organize.md
+        "mpm-config-view.md",  # Replaced by mpm-config.md
         "mpm-resume.md",  # Replaced by mpm-session-resume.md
         "mpm-ticket.md",  # Replaced by mpm-ticket-view.md
     ]
@@ -315,8 +314,7 @@ class CommandDeploymentService(BaseService):
         replacement_map = {
             "mpm-agents.md": "mpm-agents-list.md",
             "mpm-auto-configure.md": "mpm-agents-auto-configure.md",
-            "mpm-config.md": "mpm-config-view.md",
-            "mpm-organize.md": "mpm-ticket-organize.md",
+            "mpm-config-view.md": "mpm-config.md",
             "mpm-resume.md": "mpm-session-resume.md",
             "mpm-ticket.md": "mpm-ticket-view.md",
         }
@@ -345,13 +343,71 @@ class CommandDeploymentService(BaseService):
 
         return removed
 
+    def remove_stale_commands(self) -> int:
+        """Remove stale MPM commands that no longer exist in source.
+
+        This method cleans up deployed commands that have been deleted or renamed
+        in the source directory. It's called automatically on startup to ensure
+        deployed commands stay in sync with source.
+
+        Returns:
+            Number of stale files removed
+        """
+        if not self.target_dir.exists():
+            self.logger.debug(
+                f"Target directory does not exist: {self.target_dir}, skipping stale command cleanup"
+            )
+            return 0
+
+        if not self.source_dir.exists():
+            self.logger.warning(
+                f"Source directory does not exist: {self.source_dir}, cannot detect stale commands"
+            )
+            return 0
+
+        # Get current source commands (ground truth)
+        source_commands = {f.name for f in self.source_dir.glob("mpm*.md")}
+
+        # Get deployed commands
+        deployed_commands = {f.name for f in self.target_dir.glob("mpm*.md")}
+
+        # Find stale commands (deployed but not in source, excluding deprecated)
+        stale_commands = (
+            deployed_commands - source_commands - set(self.DEPRECATED_COMMANDS)
+        )
+
+        if not stale_commands:
+            self.logger.debug("No stale commands found to remove")
+            return 0
+
+        removed = 0
+        self.logger.info(f"Cleaning up {len(stale_commands)} stale command(s)...")
+
+        for stale_cmd in stale_commands:
+            stale_file = self.target_dir / stale_cmd
+            try:
+                stale_file.unlink()
+                self.logger.info(
+                    f"Removed stale command: {stale_cmd} (no longer in source)"
+                )
+                removed += 1
+            except Exception as e:
+                # Log error but don't fail startup - this is non-critical
+                self.logger.warning(f"Failed to remove stale command {stale_cmd}: {e}")
+
+        if removed > 0:
+            self.logger.info(f"Removed {removed} stale command(s)")
+
+        return removed
+
 
 def deploy_commands_on_startup(force: bool = False) -> None:
     """Convenience function to deploy commands during startup.
 
     This function:
     1. Removes deprecated commands that have been replaced
-    2. Deploys current command files
+    2. Removes stale commands that no longer exist in source
+    3. Deploys current command files
 
     Args:
         force: Force deployment even if files exist
@@ -359,12 +415,17 @@ def deploy_commands_on_startup(force: bool = False) -> None:
     service = CommandDeploymentService()
     logger = get_logger("startup")
 
-    # Clean up deprecated commands BEFORE deploying new ones
-    removed_count = service.remove_deprecated_commands()
-    if removed_count > 0:
-        logger.info(f"Cleaned up {removed_count} deprecated command(s)")
+    # Clean up deprecated commands FIRST (known old commands)
+    deprecated_count = service.remove_deprecated_commands()
+    if deprecated_count > 0:
+        logger.info(f"Cleaned up {deprecated_count} deprecated command(s)")
+
+    # Clean up stale commands SECOND (deployed but not in source anymore)
+    stale_count = service.remove_stale_commands()
+    if stale_count > 0:
+        logger.info(f"Cleaned up {stale_count} stale command(s)")
 
-    # Deploy current commands
+    # Deploy current commands LAST
     result = service.deploy_commands(force=force)
 
     if result["deployed"]:

claude_mpm/services/event_bus/config.py

@@ -52,9 +52,11 @@ class EventBusConfig:
     )
 
     # Relay configuration
+    # DirectSocketIORelay disabled by default - events already emit via direct sio.emit()
+    # Enable with CLAUDE_MPM_RELAY_ENABLED=true if needed for external consumers
     relay_enabled: bool = field(
         default_factory=lambda: os.environ.get(
-            "CLAUDE_MPM_RELAY_ENABLED", "true"
+            "CLAUDE_MPM_RELAY_ENABLED", "false"
         ).lower()
         == "true"
     )

claude_mpm/services/git/git_operations_service.py

@@ -18,10 +18,13 @@ Example:
     ...     service.commit(Path("~/.claude-mpm/cache/remote-agents"), "feat: improve research agent memory handling")
 """
 
+import logging
 import subprocess
 from pathlib import Path
 from typing import List, Optional, Tuple
 
+logger = logging.getLogger(__name__)
+
 
 # Custom Exceptions
 class GitOperationError(Exception):
@@ -314,7 +317,12 @@ class GitOperationsService:
 
     def pull(self, repo_path: Path, branch: str = "main") -> bool:
         """
-        Pull latest changes from remote.
+        Pull latest changes from remote with automatic divergent branch recovery.
+
+        For cache/sync repositories, automatically handles divergent branches by:
+        1. First attempting git pull --rebase (cleaner history)
+        2. If rebase fails or conflicts exist, hard reset to match remote exactly
+           (cache repos should mirror remote state, local changes are discarded)
 
         Args:
             repo_path: Repository path
@@ -325,21 +333,98 @@ class GitOperationsService:
 
         Raises:
             GitOperationError: If pull fails
-            GitConflictError: If merge conflicts detected
+            GitConflictError: If merge conflicts detected and cannot be auto-resolved
         """
         self._validate_repo(repo_path)
 
+        # First, try standard pull
         returncode, _stdout, stderr = self._run_git_command(
             ["git", "pull", "origin", branch], cwd=repo_path
         )
 
-        if returncode != 0:
-            # Check for merge conflicts
-            if "conflict" in stderr.lower():
-                raise GitConflictError(
-                    f"Merge conflicts detected when pulling {branch}: {stderr}"
+        if returncode == 0:
+            return True
+
+        # Check if this is a divergent branch situation
+        is_divergent = any(
+            phrase in stderr.lower()
+            for phrase in [
+                "divergent branches",
+                "need to specify how to reconcile",
+                "have diverged",
+            ]
+        )
+
+        if is_divergent:
+            logger.warning(
+                f"Divergent branches detected in cache repository at {repo_path}. "
+                "Attempting automatic recovery with rebase..."
+            )
+
+            # Strategy 1: Try rebase for cleaner history
+            returncode, _stdout, stderr = self._run_git_command(
+                ["git", "pull", "--rebase", "origin", branch], cwd=repo_path
+            )
+
+            if returncode == 0:
+                logger.info(
+                    f"Successfully resolved divergent branches with rebase for {branch}"
+                )
+                return True
+
+            # Check if rebase had conflicts
+            has_rebase_conflict = any(
+                phrase in stderr.lower()
+                for phrase in ["conflict", "rebase in progress"]
+            )
+
+            if has_rebase_conflict:
+                logger.warning(
+                    "Rebase conflicts detected. Aborting rebase and resetting to remote state..."
                 )
-            raise GitOperationError(f"Failed to pull {branch}: {stderr}")
+                # Abort the rebase
+                self._run_git_command(["git", "rebase", "--abort"], cwd=repo_path)
+
+            # Strategy 2: Hard reset to match remote exactly (cache repos should mirror remote)
+            logger.warning(
+                f"Discarding local changes and resetting to origin/{branch} "
+                "(cache repositories should match remote exactly)"
+            )
+
+            # Fetch latest to ensure we have the remote state
+            returncode, _stdout, stderr = self._run_git_command(
+                ["git", "fetch", "origin", branch], cwd=repo_path
+            )
+
+            if returncode != 0:
+                raise GitOperationError(
+                    f"Failed to fetch from remote during divergent branch recovery: {stderr}"
+                )
+
+            # Hard reset to remote branch
+            returncode, _stdout, stderr = self._run_git_command(
+                ["git", "reset", "--hard", f"origin/{branch}"], cwd=repo_path
+            )
+
+            if returncode != 0:
+                raise GitOperationError(
+                    f"Failed to reset to origin/{branch} during divergent branch recovery: {stderr}"
+                )
+
+            logger.info(
+                f"Successfully reset cache repository to origin/{branch} "
+                "(local changes discarded)"
+            )
+            return True
+
+        # Check for merge conflicts (non-divergent case)
+        if "conflict" in stderr.lower():
+            raise GitConflictError(
+                f"Merge conflicts detected when pulling {branch}: {stderr}"
+            )
+
+        # Other pull errors
+        raise GitOperationError(f"Failed to pull {branch}: {stderr}")
 
         return True
 

claude_mpm/services/monitor/daemon.py

@@ -44,6 +44,7 @@ class UnifiedMonitorDaemon:
         daemon_mode: bool = False,
         pid_file: Optional[str] = None,
         log_file: Optional[str] = None,
+        enable_hot_reload: bool = False,
     ):
         """Initialize the unified monitor daemon.
 
@@ -53,10 +54,12 @@ class UnifiedMonitorDaemon:
             daemon_mode: Whether to run as background daemon
             pid_file: Path to PID file for daemon mode
             log_file: Path to log file for daemon mode
+            enable_hot_reload: Enable file watching and hot reload for development
         """
         self.host = host
         self.port = port
         self.daemon_mode = daemon_mode
+        self.enable_hot_reload = enable_hot_reload
         self.logger = get_logger(__name__)
 
         # Use new consolidated DaemonManager for all daemon operations
@@ -75,7 +78,9 @@ class UnifiedMonitorDaemon:
         )
 
         # Core server
-        self.server = UnifiedMonitorServer(host=host, port=port)
+        self.server = UnifiedMonitorServer(
+            host=host, port=port, enable_hot_reload=enable_hot_reload
+        )
 
         # Health monitoring
         self.health_monitor = HealthMonitor(port=port)
@@ -510,7 +515,9 @@ class UnifiedMonitorDaemon:
 
         # Recreate the server and health monitor after stop() sets them to None
         self.logger.info(f"Recreating server components for {self.host}:{self.port}")
-        self.server = UnifiedMonitorServer(host=self.host, port=self.port)
+        self.server = UnifiedMonitorServer(
+            host=self.host, port=self.port, enable_hot_reload=self.enable_hot_reload
+        )
         self.health_monitor = HealthMonitor(port=self.port)
 
         # Reset the shutdown event for the new run

claude_mpm/services/monitor/daemon_manager.py

@@ -34,6 +34,11 @@ from typing import Optional, Tuple
 from ...core.enums import OperationResult
 from ...core.logging_config import get_logger
 
+# Exit code constants for signal handling
+EXIT_NORMAL = 0
+EXIT_SIGKILL = 137  # 128 + SIGKILL(9) - forced termination
+EXIT_SIGTERM = 143  # 128 + SIGTERM(15) - graceful shutdown
+
 
 class DaemonManager:
     """Centralized manager for all daemon lifecycle operations.
@@ -556,7 +561,7 @@ class DaemonManager:
             # Use subprocess for clean daemon startup (v4.2.40)
             # This avoids fork() issues with Python threading
             if self.use_subprocess_daemon():
-                return self.start_daemon_subprocess()
+                return self.start_daemon_subprocess(force_restart=force_restart)
             # Fallback to traditional fork (kept for compatibility)
             return self.daemonize()
 
@@ -574,12 +579,15 @@ class DaemonManager:
         # Otherwise, use subprocess for monitor daemon to avoid threading issues
         return True
 
-    def start_daemon_subprocess(self) -> bool:
+    def start_daemon_subprocess(self, force_restart: bool = False) -> bool:
         """Start daemon using subprocess.Popen for clean process isolation.
 
         This avoids all the fork() + threading issues by starting the monitor
         in a completely fresh process with no inherited threads or locks.
 
+        Args:
+            force_restart: Whether this is a force restart (helps interpret exit codes)
+
         Returns:
             True if daemon started successfully
         """
@@ -652,7 +660,35 @@ class DaemonManager:
                     # Check if process is still running
                     returncode = process.poll()
                     if returncode is not None:
-                        # Process exited - this is the bug we're fixing!
+                        # Process exited - interpret exit code with context
+                        # Exit codes 137 (SIGKILL) and 143 (SIGTERM) are common during daemon replacement
+                        if returncode == EXIT_SIGKILL:
+                            # SIGKILL - process was forcefully terminated
+                            if force_restart:
+                                # This is expected during force restart - old daemon was killed
+                                self.logger.info(
+                                    f"Previous monitor instance replaced (exit {EXIT_SIGKILL}: SIGKILL during force restart)"
+                                )
+                            else:
+                                # Unexpected SIGKILL - something else killed our new daemon
+                                self.logger.warning(
+                                    f"Monitor subprocess terminated unexpectedly (exit {EXIT_SIGKILL}: SIGKILL). "
+                                    f"Check {self.log_file} for details."
+                                )
+                            return False
+                        if returncode == EXIT_SIGTERM:
+                            # SIGTERM - graceful shutdown requested
+                            self.logger.info(
+                                f"Monitor subprocess cleanly terminated (exit {EXIT_SIGTERM}: SIGTERM, graceful shutdown)"
+                            )
+                            return False
+                        if returncode == EXIT_NORMAL:
+                            # Normal exit
+                            self.logger.info(
+                                f"Monitor subprocess exited normally (exit code {EXIT_NORMAL})"
+                            )
+                            return False
+                        # Unexpected exit code - this IS an error
                         self.logger.error(
                             f"Monitor daemon subprocess exited prematurely with code {returncode}"
                         )