claude-mpm 5.6.1__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/core/claude_runner.py

@@ -1,5 +1,7 @@
 """Claude runner with both exec and subprocess launch methods."""
 
+import hashlib
+import json
 import os
 from pathlib import Path
 from typing import Optional
@@ -211,9 +213,146 @@ class ClaudeRunner:
                 }
             )
 
+    def _get_deployment_state_path(self) -> Path:
+        """Get path to deployment state file.
+
+        CRITICAL: Must match path used by startup.py::_save_deployment_state_after_reconciliation()
+        Located at: .claude-mpm/cache/deployment_state.json
+        """
+        return Path.cwd() / ".claude-mpm" / "cache" / "deployment_state.json"
+
+    def _calculate_deployment_hash(self, agents_dir: Path) -> str:
+        """Calculate hash of all agent files for change detection.
+
+        Args:
+            agents_dir: Directory containing agent .md files
+
+        Returns:
+            SHA256 hash of agent file contents
+        """
+        if not agents_dir.exists():
+            return ""
+
+        # Get all .md files sorted for consistent hashing
+        agent_files = sorted(agents_dir.glob("*.md"))
+
+        hash_obj = hashlib.sha256()
+        for agent_file in agent_files:
+            # Include filename and content in hash
+            hash_obj.update(agent_file.name.encode())
+            try:
+                hash_obj.update(agent_file.read_bytes())
+            except Exception as e:
+                self.logger.debug(f"Error reading {agent_file} for hash: {e}")
+
+        return hash_obj.hexdigest()
+
+    def _check_deployment_state(self) -> bool:
+        """Check if agents are already deployed and up-to-date.
+
+        Returns:
+            True if agents are already deployed and match current version, False otherwise
+        """
+        state_file = self._get_deployment_state_path()
+        agents_dir = Path.cwd() / ".claude" / "agents"
+
+        # If state file doesn't exist, need to deploy
+        if not state_file.exists():
+            return False
+
+        # If agents directory doesn't exist, need to deploy
+        if not agents_dir.exists():
+            return False
+
+        try:
+            # Load deployment state
+            state_data = json.loads(state_file.read_text())
+
+            # Get current version from package
+            from claude_mpm import __version__
+
+            # Check if version matches
+            if state_data.get("version") != __version__:
+                self.logger.debug(
+                    f"Version mismatch: {state_data.get('version')} != {__version__}"
+                )
+                return False
+
+            # Check if agent count and hash match
+            current_hash = self._calculate_deployment_hash(agents_dir)
+            stored_hash = state_data.get("deployment_hash", "")
+
+            if current_hash != stored_hash:
+                self.logger.debug("Agent deployment hash mismatch")
+                return False
+
+            # All checks passed - agents are already deployed
+            agent_count = state_data.get("agent_count", 0)
+            self.logger.debug(
+                f"Agents already deployed: {agent_count} agents (v{__version__})"
+            )
+            return True
+
+        except Exception as e:
+            self.logger.debug(f"Error checking deployment state: {e}")
+            return False
+
+    def _save_deployment_state(self, agent_count: int) -> None:
+        """Save current deployment state.
+
+        Args:
+            agent_count: Number of agents deployed
+        """
+        state_file = self._get_deployment_state_path()
+        agents_dir = Path.cwd() / ".claude" / "agents"
+
+        try:
+            import time
+
+            from claude_mpm import __version__
+
+            # Calculate deployment hash
+            deployment_hash = self._calculate_deployment_hash(agents_dir)
+
+            # Create state data
+            state_data = {
+                "version": __version__,
+                "agent_count": agent_count,
+                "deployment_hash": deployment_hash,
+                "deployed_at": time.time(),
+            }
+
+            # Ensure directory exists
+            state_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write state file
+            state_file.write_text(json.dumps(state_data, indent=2))
+            self.logger.debug(f"Saved deployment state: {agent_count} agents")
+
+        except Exception as e:
+            self.logger.debug(f"Error saving deployment state: {e}")
+
     def setup_agents(self) -> bool:
         """Deploy native agents to .claude/agents/."""
         try:
+            # SIMPLE CHECK: If agents already exist from reconciliation, skip deployment
+            # This ensures reconciliation's user-configured agents are never overwritten
+            agents_dir = Path.cwd() / ".claude" / "agents"
+            if agents_dir.exists():
+                existing_agents = list(agents_dir.glob("*.md"))
+                if len(existing_agents) > 0:
+                    # Reconciliation already deployed agents - skip
+                    self.logger.debug(
+                        f"Skipping setup_agents: {len(existing_agents)} agents already deployed by reconciliation"
+                    )
+                    if self.project_logger:
+                        self.project_logger.log_system(
+                            f"Agents already deployed via reconciliation: {len(existing_agents)} agents",
+                            level="DEBUG",
+                            component="deployment",
+                        )
+                    return True
+
             if self.project_logger:
                 self.project_logger.log_system(
                     "Starting agent deployment", level="INFO", component="deployment"
@@ -239,6 +378,12 @@ class ClaudeRunner:
 
                 # Set Claude environment
                 self.deployment_service.set_claude_environment()
+
+                # Save deployment state for future runs
+                agents_dir = Path.cwd() / ".claude" / "agents"
+                total_agents = len(list(agents_dir.glob("*.md")))
+                self._save_deployment_state(total_agents)
+
                 return True
             self.logger.info("All agents already up to date")
             if self.project_logger:
@@ -247,6 +392,13 @@ class ClaudeRunner:
                     level="INFO",
                     component="deployment",
                 )
+
+            # Save deployment state even if no changes
+            agents_dir = Path.cwd() / ".claude" / "agents"
+            if agents_dir.exists():
+                total_agents = len(list(agents_dir.glob("*.md")))
+                self._save_deployment_state(total_agents)
+
             return True
 
         except PermissionError as e:

claude_mpm/core/config.py

@@ -12,11 +12,10 @@ import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-import yaml
-
 from claude_mpm.core.logging_utils import get_logger
 
-from ..utils.config_manager import ConfigurationManager
+# Lazy import ConfigurationManager to avoid importing yaml at module level
+# This prevents hook errors when yaml isn't available in the execution environment
 from .exceptions import ConfigurationError, FileOperationError
 from .unified_paths import get_path_manager
 
@@ -104,6 +103,9 @@ class Config:
             Config._initialized = True
             logger.debug("Initializing Config singleton for the first time")
 
+            # Lazy import ConfigurationManager at runtime to avoid yaml import at module level
+            from ..utils.config_manager import ConfigurationManager
+
             # Initialize instance variables inside the lock to ensure thread safety
             self._config: Dict[str, Any] = {}
             self._env_prefix = env_prefix
@@ -224,21 +226,6 @@ class Config:
                             f"Response logging format: {response_logging.get('format', 'json')}"
                         )
 
-        except yaml.YAMLError as e:
-            logger.error(f"YAML syntax error in {file_path}: {e}")
-            if hasattr(e, "problem_mark"):
-                mark = e.problem_mark
-                logger.error(f"Error at line {mark.line + 1}, column {mark.column + 1}")
-            logger.info(
-                "TIP: Validate your YAML at https://www.yamllint.com/ or run: python scripts/validate_configuration.py"
-            )
-            logger.info(
-                "TIP: Common issue - YAML requires spaces, not tabs. Fix with: sed -i '' 's/\t/    /g' "
-                + str(file_path)
-            )
-            # Store error for later retrieval
-            self._config["_load_error"] = str(e)
-
         except json.JSONDecodeError as e:
             logger.error(f"JSON syntax error in {file_path}: {e}")
             logger.error(f"Error at line {e.lineno}, column {e.colno}")
@@ -255,7 +242,28 @@ class Config:
                 },
             ) from e
         except Exception as e:
-            # Catch any remaining unexpected errors and wrap them as configuration errors
+            # Handle YAML errors without importing yaml at module level
+            # ConfigurationManager.load_yaml raises yaml.YAMLError, but we don't want to import yaml
+            # Check if it's a YAML error by class name to avoid import
+            if e.__class__.__name__ == "YAMLError":
+                logger.error(f"YAML syntax error in {file_path}: {e}")
+                if hasattr(e, "problem_mark"):
+                    mark = e.problem_mark
+                    logger.error(
+                        f"Error at line {mark.line + 1}, column {mark.column + 1}"
+                    )
+                logger.info(
+                    "TIP: Validate your YAML at https://www.yamllint.com/ or run: python scripts/validate_configuration.py"
+                )
+                logger.info(
+                    "TIP: Common issue - YAML requires spaces, not tabs. Fix with: sed -i '' 's/\t/    /g' "
+                    + str(file_path)
+                )
+                # Store error for later retrieval
+                self._config["_load_error"] = str(e)
+                return  # Don't re-raise, we handled it
+
+            # Not a YAML error, wrap as configuration error
             raise ConfigurationError(
                 f"Unexpected error loading configuration from {file_path}: {e}",
                 context={
@@ -491,7 +499,7 @@ class Config:
             # Socket.IO server health and recovery configuration
             "socketio_server": {
                 "host": "localhost",
-                "port": 8765,
+                "port": 8768,  # Default SocketIO port (from network_config.NetworkPorts)
                 "enable_health_monitoring": True,
                 "enable_recovery": True,
                 "health_monitoring": {
@@ -532,7 +540,7 @@ class Config:
             # Monitor server configuration (decoupled from dashboard)
             "monitor_server": {
                 "host": "localhost",
-                "port": 8765,  # Default monitor port (shared with dashboard)
+                "port": 8765,  # Default monitor port (from network_config.NetworkPorts.MONITOR_DEFAULT)
                 "enable_health_monitoring": True,
                 "auto_start": False,  # Don't auto-start with dashboard by default
                 "event_buffer_size": 2000,  # Larger buffer for monitor server
@@ -541,7 +549,7 @@ class Config:
             # Dashboard server configuration (connects to monitor)
             "dashboard_server": {
                 "host": "localhost",
-                "port": 8765,  # Dashboard UI port
+                "port": 8767,  # Dashboard UI port (from network_config.NetworkPorts.DASHBOARD_DEFAULT)
                 "monitor_host": "localhost",  # Monitor server host to connect to
                 "monitor_port": 8765,  # Monitor server port to connect to
                 "auto_connect_monitor": True,  # Automatically connect to monitor

claude_mpm/core/config_constants.py

@@ -44,11 +44,14 @@ class ConfigConstants:
             "startup": 60,
             "graceful_shutdown": 30,
         },
-        # Ports
+        # Ports (updated to use network_config.NetworkPorts defaults)
         "ports": {
-            "socketio_default": 8765,
-            "socketio_range_start": 8765,
-            "socketio_range_end": 8775,
+            "monitor_default": 8765,  # NetworkPorts.MONITOR_DEFAULT
+            "commander_default": 8766,  # NetworkPorts.COMMANDER_DEFAULT
+            "dashboard_default": 8767,  # NetworkPorts.DASHBOARD_DEFAULT
+            "socketio_default": 8768,  # NetworkPorts.SOCKETIO_DEFAULT
+            "socketio_range_start": 8765,  # NetworkPorts.PORT_RANGE_START
+            "socketio_range_end": 8785,  # NetworkPorts.PORT_RANGE_END
         },
         # Cache settings
         "cache": {
@@ -134,23 +137,70 @@ class ConfigConstants:
         Get port value by type.
 
         Args:
-            port_type: Type of port (e.g., 'socketio_default')
+            port_type: Type of port (e.g., 'socketio_default', 'monitor_default')
 
         Returns:
             Port number
         """
         try:
+            # Try to get from unified config first
             config = cls._get_config_service().config
 
+            if port_type == "monitor_default":
+                return (
+                    config.network.monitor_port
+                    if hasattr(config.network, "monitor_port")
+                    else 8765
+                )
+            if port_type == "commander_default":
+                return (
+                    config.network.commander_port
+                    if hasattr(config.network, "commander_port")
+                    else 8766
+                )
+            if port_type == "dashboard_default":
+                return (
+                    config.network.dashboard_port
+                    if hasattr(config.network, "dashboard_port")
+                    else 8767
+                )
             if port_type == "socketio_default":
-                return config.network.socketio_port
+                return (
+                    config.network.socketio_port
+                    if hasattr(config.network, "socketio_port")
+                    else 8768
+                )
             if port_type == "socketio_range_start":
-                return config.network.socketio_port_range[0]
+                return (
+                    config.network.socketio_port_range[0]
+                    if hasattr(config.network, "socketio_port_range")
+                    else 8765
+                )
             if port_type == "socketio_range_end":
-                return config.network.socketio_port_range[1]
+                return (
+                    config.network.socketio_port_range[1]
+                    if hasattr(config.network, "socketio_port_range")
+                    else 8785
+                )
             return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
         except Exception:
-            return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
+            # Fallback to network_config.NetworkPorts or DEFAULT_VALUES
+            try:
+                from .network_config import NetworkPorts
+
+                port_map = {
+                    "monitor_default": NetworkPorts.MONITOR_DEFAULT,
+                    "commander_default": NetworkPorts.COMMANDER_DEFAULT,
+                    "dashboard_default": NetworkPorts.DASHBOARD_DEFAULT,
+                    "socketio_default": NetworkPorts.SOCKETIO_DEFAULT,
+                    "socketio_range_start": NetworkPorts.PORT_RANGE_START,
+                    "socketio_range_end": NetworkPorts.PORT_RANGE_END,
+                }
+                return port_map.get(
+                    port_type, cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
+                )
+            except Exception:
+                return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
 
     @classmethod
     def get_cache_setting(cls, setting_name: str) -> Any:
@@ -304,6 +354,21 @@ def get_socketio_port() -> int:
     return ConfigConstants.get_port("socketio_default")
 
 
+def get_monitor_port() -> int:
+    """Get default monitor port."""
+    return ConfigConstants.get_port("monitor_default")
+
+
+def get_commander_port() -> int:
+    """Get default commander port."""
+    return ConfigConstants.get_port("commander_default")
+
+
+def get_dashboard_port() -> int:
+    """Get default dashboard port."""
+    return ConfigConstants.get_port("dashboard_default")
+
+
 def get_cache_size() -> float:
     """Get default cache size in MB."""
     return ConfigConstants.get_cache_setting("max_size_mb")

claude_mpm/core/constants.py

@@ -38,12 +38,36 @@ class SystemLimits:
 
 
 class NetworkConfig:
-    """Network-related configuration constants."""
+    """Network-related configuration constants.
 
-    # Port ranges
-    SOCKETIO_PORT_RANGE: Tuple[int, int] = (8765, 8785)
-    DEFAULT_SOCKETIO_PORT = 8765
-    DEFAULT_DASHBOARD_PORT = 8765
+    NOTE: Port defaults are now centralized in network_config.NetworkPorts.
+    This class maintains backward compatibility but delegates to NetworkPorts.
+    """
+
+    # Import from network_config for single source of truth
+    # Lazy import to avoid circular dependencies
+    @property
+    def SOCKETIO_PORT_RANGE(self) -> Tuple[int, int]:
+        from .network_config import NetworkPorts
+
+        return (NetworkPorts.PORT_RANGE_START, NetworkPorts.PORT_RANGE_END)
+
+    @property
+    def DEFAULT_SOCKETIO_PORT(self) -> int:
+        from .network_config import NetworkPorts
+
+        return NetworkPorts.SOCKETIO_DEFAULT
+
+    @property
+    def DEFAULT_DASHBOARD_PORT(self) -> int:
+        from .network_config import NetworkPorts
+
+        return NetworkPorts.DASHBOARD_DEFAULT
+
+    # Port ranges (module-level for backward compatibility)
+    SOCKETIO_PORT_RANGE: Tuple[int, int] = (8765, 8785)  # Will be updated at runtime
+    DEFAULT_SOCKETIO_PORT = 8768  # Updated to match new default
+    DEFAULT_DASHBOARD_PORT = 8767  # Updated to match new default
 
     # Connection timeouts (seconds)
     CONNECTION_TIMEOUT = 5.0
@@ -303,18 +327,38 @@ DEFAULT_TIMEOUT = TimeoutConfig.DEFAULT_TIMEOUT
 
 
 class NetworkPorts:
-    """Network port configuration."""
+    """Network port configuration.
+
+    DEPRECATED: Use claude_mpm.core.network_config.NetworkPorts instead.
+    This class is maintained for backward compatibility.
+    """
+
+    # Import from network_config for single source of truth
+    @classmethod
+    def _get_config(cls):
+        from .network_config import NetworkPorts as NewNetworkPorts
+
+        return NewNetworkPorts
+
+    # Delegate to new NetworkPorts
+    @property
+    def DEFAULT_SOCKETIO(self) -> int:
+        return self._get_config().SOCKETIO_DEFAULT
+
+    @property
+    def DEFAULT_DASHBOARD(self) -> int:
+        return self._get_config().DASHBOARD_DEFAULT
 
-    # Use existing values from NetworkConfig
-    DEFAULT_SOCKETIO = NetworkConfig.DEFAULT_SOCKETIO_PORT
-    DEFAULT_DASHBOARD = NetworkConfig.DEFAULT_DASHBOARD_PORT
-    PORT_RANGE_START = NetworkConfig.SOCKETIO_PORT_RANGE[0]
-    PORT_RANGE_END = NetworkConfig.SOCKETIO_PORT_RANGE[1]
+    # Keep class-level attributes for compatibility
+    DEFAULT_SOCKETIO = 8768  # Updated to match network_config
+    DEFAULT_DASHBOARD = 8767  # Updated to match network_config
+    PORT_RANGE_START = 8765
+    PORT_RANGE_END = 8785
 
     @classmethod
     def get_port_range(cls) -> range:
         """Get the valid port range."""
-        return range(cls.PORT_RANGE_START, cls.PORT_RANGE_END + 1)
+        return cls._get_config().get_port_range()
 
 
 class ProjectPaths:

claude_mpm/core/hook_manager.py

@@ -186,8 +186,9 @@ class HookManager:
             env["CLAUDE_MPM_HOOK_DEBUG"] = "true"
 
             # Execute with timeout in background thread
+            # Run as module to ensure proper package context for relative imports
             result = subprocess.run(  # nosec B603 B607
-                ["python", str(self.hook_handler_path)],
+                ["python", "-m", "claude_mpm.hooks.claude_hooks.hook_handler"],
                 input=event_json,
                 text=True,
                 capture_output=True,

claude_mpm/core/interactive_session.py

@@ -143,11 +143,12 @@ class InteractiveSession:
             Tuple of (success, environment_dict)
         """
         try:
-            # Deploy system agents
-            if not self.runner.setup_agents():
-                print("Continuing without native agents...")
+            # NOTE: System agents are deployed via reconciliation during startup.
+            # The reconciliation process respects user configuration and handles
+            # both native and custom mode deployment. No need to call setup_agents() here.
 
-            # Deploy project-specific agents
+            # Deploy project-specific agents from .claude-mpm/agents/
+            # This is separate from system agents and handles user-defined agents
             self.runner.deploy_project_agents_to_claude()
 
             # Build command

claude_mpm/core/logger.py

@@ -391,8 +391,22 @@ def cleanup_old_mpm_logs(
 
 
 def get_logger(name: str) -> logging.Logger:
-    """Get a logger instance."""
-    return logging.getLogger(f"claude_mpm.{name}")
+    """Get a logger instance.
+
+    CRITICAL: Respects startup suppression mode (CRITICAL+1) to prevent
+    early INFO logs before setup_logging() is called.
+    """
+    logger = logging.getLogger(f"claude_mpm.{name}")
+
+    # Check if root logger is suppressed (startup.py sets CRITICAL+1)
+    root_logger = logging.getLogger()
+    if root_logger.level > logging.CRITICAL:
+        # Suppression active - ensure this logger is also suppressed
+        logger.setLevel(logging.CRITICAL + 1)
+        logger.handlers = []
+        logger.propagate = False
+
+    return logger
 
 
 def setup_streaming_logger(name: str, level: str = "INFO") -> logging.Logger:

claude_mpm/core/logging_utils.py

@@ -103,23 +103,47 @@ class LoggerFactory:
 
         # Set up root logger
         root_logger = logging.getLogger()
-        root_logger.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
-
-        # Remove existing handlers
-        root_logger.handlers = []
-
-        # Console handler - MUST use stderr to avoid corrupting hook JSON output
-        # WHY stderr: Hook handlers output JSON to stdout. Logging to stdout
-        # corrupts this JSON and causes "hook error" messages from Claude Code.
-        console_handler = logging.StreamHandler(sys.stderr)
-        console_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
-        console_formatter = logging.Formatter(
-            log_format or LoggingConfig.DEFAULT_FORMAT,
-            date_format or LoggingConfig.DATE_FORMAT,
+
+        # CRITICAL FIX: Respect existing root logger suppression
+        # If root logger is already set to CRITICAL+1 (suppressed by startup.py),
+        # don't override it. This prevents logging from appearing during startup
+        # before the CLI's setup_logging() runs.
+        current_level = root_logger.level
+        desired_level = LoggingConfig.LEVELS.get(cls._log_level, logging.INFO)
+
+        # Only set level if current is unset (0) or lower than desired
+        # CRITICAL+1 is 51, so this check preserves suppression
+        should_configure_logging = current_level == 0 or (
+            current_level < desired_level and current_level <= logging.CRITICAL
         )
-        console_handler.setFormatter(console_formatter)
-        root_logger.addHandler(console_handler)
-        cls._handlers["console"] = console_handler
+
+        if should_configure_logging:
+            root_logger.setLevel(desired_level)
+        # else: root logger is suppressed (CRITICAL+1), keep it suppressed
+
+        # Preserve FileHandlers (e.g., hooks logging), only remove StreamHandlers
+        root_logger.handlers = [
+            h for h in root_logger.handlers if isinstance(h, logging.FileHandler)
+        ]
+
+        # CRITICAL FIX: Don't add handlers if logging is suppressed
+        # If root logger is at CRITICAL+1 (startup suppression), don't add any handlers
+        # This prevents early imports from logging before CLI setup_logging() runs
+        if should_configure_logging:
+            # Console handler - MUST use stderr to avoid corrupting hook JSON output
+            # WHY stderr: Hook handlers output JSON to stdout. Logging to stdout
+            # corrupts this JSON and causes "hook error" messages from Claude Code.
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(
+                LoggingConfig.LEVELS.get(cls._log_level, logging.INFO)
+            )
+            console_formatter = logging.Formatter(
+                log_format or LoggingConfig.DEFAULT_FORMAT,
+                date_format or LoggingConfig.DATE_FORMAT,
+            )
+            console_handler.setFormatter(console_formatter)
+            root_logger.addHandler(console_handler)
+            cls._handlers["console"] = console_handler
 
         # File handler (optional)
         if log_to_file and cls._log_dir: