claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

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/framework/formatters/content_formatter.py

@@ -100,19 +100,9 @@ class ContentFormatter:
                 instructions += framework_content["actual_memories"]
                 instructions += "\n"
 
-            # Add agent memories if available
-            if framework_content.get("agent_memories"):
-                agent_memories = framework_content["agent_memories"]
-                if agent_memories:
-                    instructions += "\n\n## Agent Memories\n\n"
-                    instructions += "**The following are accumulated memories from specialized agents:**\n\n"
-
-                    for agent_name in sorted(agent_memories.keys()):
-                        memory_content = agent_memories[agent_name]
-                        if memory_content:
-                            instructions += f"### {agent_name.replace('_', ' ').title()} Agent Memory\n\n"
-                            instructions += memory_content
-                            instructions += "\n\n"
+            # NOTE: Agent memories are now injected at agent deployment time
+            # in agent_template_builder.py, not in PM instructions.
+            # This ensures each agent gets its own memory, not all memories embedded in PM.
 
             # Add dynamic agent capabilities section
             instructions += capabilities_section

claude_mpm/core/framework/loaders/agent_loader.py

@@ -115,7 +115,11 @@ class AgentLoader:
         return agents
 
     def discover_local_json_templates(self) -> Dict[str, Dict[str, Any]]:
-        """Discover local JSON agent templates from .claude-mpm/agents/ directories.
+        """Discover local JSON agent templates.
+
+        NOTE: This method is kept for backward compatibility but is deprecated.
+        The new architecture uses SOURCE (~/.claude-mpm/cache/agents/)
+        and DEPLOYMENT (.claude/agents/) locations only.
 
         Returns:
             Dictionary mapping agent IDs to agent metadata
@@ -125,11 +129,10 @@ class AgentLoader:
         local_agents = {}
 
         # Check for local JSON templates in priority order
+        # NOTE: These directories are deprecated in the simplified architecture
         template_dirs = [
-            Path.cwd()
-            / ".claude-mpm"
-            / "agents",  # Project local agents (highest priority)
-            Path.home() / ".claude-mpm" / "agents",  # User local agents
+            Path.cwd() / ".claude-mpm" / "agents",  # Deprecated: Project local agents
+            Path.home() / ".claude-mpm" / "agents",  # Deprecated: User local agents
         ]
 
         for priority, template_dir in enumerate(template_dirs):

claude_mpm/core/framework/loaders/instruction_loader.py

@@ -88,39 +88,80 @@ class InstructionLoader:
                 self.packaged_loader.framework_last_modified
             )
 
+    def _extract_version(self, file_content: str) -> int:
+        """Extract version number from PM_INSTRUCTIONS_VERSION comment.
+
+        Args:
+            file_content: Content of the file to extract version from
+
+        Returns:
+            Version number as integer, or 0 if not found
+        """
+        import re
+
+        match = re.search(r"PM_INSTRUCTIONS_VERSION:\s*(\d+)", file_content)
+        if match:
+            return int(match.group(1))
+        return 0  # No version = oldest
+
     def _load_filesystem_framework_instructions(self, content: Dict[str, Any]) -> None:
         """Load framework instructions from filesystem.
 
         Priority order:
-        1. Deployed compiled file: .claude-mpm/PM_INSTRUCTIONS_DEPLOYED.md (HIGHEST PRIORITY)
+        1. Deployed compiled file: .claude-mpm/PM_INSTRUCTIONS_DEPLOYED.md (if version >= source)
         2. Source file (development): src/claude_mpm/agents/PM_INSTRUCTIONS.md
         3. Legacy file (backward compat): src/claude_mpm/agents/INSTRUCTIONS.md
 
+        Version validation ensures deployed file is never stale compared to source.
+
         Args:
             content: Dictionary to update with framework instructions
         """
+        # Define source path for version checking
+        pm_instructions_path = (
+            self.framework_path / "src" / "claude_mpm" / "agents" / "PM_INSTRUCTIONS.md"
+        )
+
         # PRIORITY 1: Check for compiled/deployed version in .claude-mpm/
         # This is the merged PM_INSTRUCTIONS.md + WORKFLOW.md + MEMORY.md
         deployed_path = self.current_dir / ".claude-mpm" / "PM_INSTRUCTIONS_DEPLOYED.md"
         if deployed_path.exists():
-            loaded_content = self.file_loader.try_load_file(
-                deployed_path, "deployed PM_INSTRUCTIONS_DEPLOYED.md"
-            )
-            if loaded_content:
-                content["framework_instructions"] = loaded_content
+            # Validate version before using deployed file
+            deployed_content = deployed_path.read_text()
+            deployed_version = self._extract_version(deployed_content)
+
+            # Check source version for comparison
+            if pm_instructions_path.exists():
+                source_content = pm_instructions_path.read_text()
+                source_version = self._extract_version(source_content)
+
+                if deployed_version < source_version:
+                    self.logger.warning(
+                        f"Deployed PM instructions v{deployed_version:04d} is stale, "
+                        f"source is v{source_version:04d}. Using source instead."
+                    )
+                    # Fall through to source loading - don't return early
+                else:
+                    # Version OK, use deployed
+                    content["framework_instructions"] = deployed_content
+                    content["loaded"] = True
+                    self.logger.info(
+                        f"Loaded PM_INSTRUCTIONS_DEPLOYED.md v{deployed_version:04d} from .claude-mpm/"
+                    )
+                    return  # Stop here - deployed version is current
+            else:
+                # Source doesn't exist, use deployed even without version check
+                content["framework_instructions"] = deployed_content
                 content["loaded"] = True
                 self.logger.info("Loaded PM_INSTRUCTIONS_DEPLOYED.md from .claude-mpm/")
-                return  # Stop here - deployed version takes precedence
+                return
 
         # PRIORITY 2: Development mode - load from source PM_INSTRUCTIONS.md
-        pm_instructions_path = (
-            self.framework_path / "src" / "claude_mpm" / "agents" / "PM_INSTRUCTIONS.md"
-        )
         framework_instructions_path = (
             self.framework_path / "src" / "claude_mpm" / "agents" / "INSTRUCTIONS.md"
         )
 
-        # Try loading new consolidated file
+        # Try loading new consolidated file (pm_instructions_path already defined above)
         if pm_instructions_path.exists():
             loaded_content = self.file_loader.try_load_file(
                 pm_instructions_path, "source PM_INSTRUCTIONS.md (development mode)"

claude_mpm/core/framework_loader.py

@@ -255,10 +255,12 @@ class FrameworkLoader:
         """Load actual memories using the MemoryManager service."""
         memories = self._memory_manager.load_memories()
 
+        # Only load PM memories (PM.md)
+        # Agent memories are loaded at deployment time in agent_template_builder.py
         if "actual_memories" in memories:
             content["actual_memories"] = memories["actual_memories"]
-        if "agent_memories" in memories:
-            content["agent_memories"] = memories["agent_memories"]
+        # NOTE: agent_memories are no longer loaded for PM instructions
+        # They are injected per-agent at deployment time
 
     # === Agent Discovery Methods ===
 

claude_mpm/core/hook_manager.py

@@ -16,13 +16,15 @@ import contextlib
 import json
 import os
 import queue
-import subprocess
+import subprocess  # nosec B404
 import threading
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
+from ..services.event_bus.event_bus import EventBus
+from ..services.event_log import get_event_log
 from .hook_error_memory import get_hook_error_memory
 from .hook_performance_config import get_hook_performance_config
 from .unified_paths import get_package_root
@@ -46,6 +48,10 @@ class HookManager:
         # Initialize error memory for tracking and preventing repeated errors
         self.error_memory = get_hook_error_memory()
 
+        # Initialize event log and event bus for event-driven architecture
+        self.event_log = get_event_log()
+        self.event_bus = EventBus.get_instance()
+
         # Initialize background hook processing for async execution
         self.performance_config = get_hook_performance_config()
         queue_config = self.performance_config.get_queue_config()
@@ -100,6 +106,45 @@ class HookManager:
         self.background_thread.start()
         self.logger.debug("Started background hook processor thread")
 
+    def _publish_error_event(
+        self, hook_type: str, error_info: Dict[str, str], suggestion: str
+    ):
+        """Publish hook error event to event log and event bus.
+
+        WHY publish events:
+        - Decouple error detection from error handling
+        - Enable autotodos CLI to read from persistent event log
+        - Support real-time notifications via event bus
+        - Maintain audit trail of all hook errors
+
+        Args:
+            hook_type: Type of hook that failed
+            error_info: Error information from error detection
+            suggestion: Fix suggestion from error memory
+        """
+        try:
+            # Prepare event payload
+            payload = {
+                "error_type": error_info["type"],
+                "hook_type": hook_type,
+                "details": error_info.get("details", ""),
+                "full_message": error_info.get("match", ""),
+                "suggested_fix": suggestion,
+                "source": "hook_manager",
+            }
+
+            # Publish to event log (persistent storage)
+            self.event_log.append_event(
+                event_type="autotodo.error", payload=payload, status="pending"
+            )
+
+            # Publish to event bus (real-time listeners)
+            self.event_bus.publish("autotodo.error", payload)
+
+        except Exception as e:
+            # Don't let event publishing break hook processing
+            self.logger.debug(f"Failed to publish error event: {e}")
+
     def _execute_hook_sync(self, hook_data: Dict[str, Any]):
         """Execute a single hook synchronously in the background thread with error detection.
 
@@ -141,7 +186,7 @@ class HookManager:
             env["CLAUDE_MPM_HOOK_DEBUG"] = "true"
 
             # Execute with timeout in background thread
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["python", str(self.hook_handler_path)],
                 input=event_json,
                 text=True,
@@ -157,7 +202,7 @@ class HookManager:
             )
 
             if error_info:
-                # Record the error
+                # Record the error in memory (for skipping repeated failures)
                 self.error_memory.record_error(error_info, hook_type)
 
                 # Get fix suggestion
@@ -165,6 +210,9 @@ class HookManager:
 
                 # Log error with suggestion
                 self.logger.warning(f"Hook {hook_type} error detected:\n{suggestion}")
+
+                # Publish event to event log for autotodos processing
+                self._publish_error_event(hook_type, error_info, suggestion)
             elif result.returncode != 0:
                 # Non-zero return without detected pattern
                 self.logger.debug(f"Hook {hook_type} returned code {result.returncode}")

claude_mpm/core/interactive_session.py

@@ -12,7 +12,7 @@ of InteractiveSession without circular dependency issues.
 
 import contextlib
 import os
-import subprocess
+import subprocess  # nosec B404
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
@@ -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
@@ -359,19 +360,19 @@ class InteractiveSession:
                 osm = self.runner.framework_loader.output_style_manager
                 if osm:
                     if osm.claude_version and osm.supports_output_styles():
-                        # Check if claude-mpm style is active
+                        # Check if Claude MPM style is active
                         settings_file = osm.settings_file
                         if settings_file.exists():
                             import json
 
                             settings = json.loads(settings_file.read_text())
                             active_style = settings.get("activeOutputStyle")
-                            if active_style == "claude-mpm":
-                                return "Output Style: claude-mpm ✅"
+                            if active_style in ("Claude MPM", "Claude MPM Teacher"):
+                                return f"Output Style: {active_style} ✅"
                             return f"Output Style: {active_style or 'none'}"
                         return "Output Style: Available"
                     return "Output Style: Injected (legacy)"
-        except Exception:
+        except Exception:  # nosec B110
             pass
         return None
 
@@ -582,7 +583,7 @@ class InteractiveSession:
             )
 
         # This will not return if successful
-        os.execvpe(cmd[0], cmd, env)
+        os.execvpe(cmd[0], cmd, env)  # nosec B606
         return False  # Only reached on failure
 
     def _launch_subprocess_mode(self, cmd: list, env: dict) -> bool:
@@ -641,7 +642,7 @@ class InteractiveSession:
             cmd = environment["command"]
             env = environment["environment"]
 
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603
                 cmd, stdin=None, stdout=None, stderr=None, env=env, check=False
             )
 

claude_mpm/core/logger.py

@@ -175,6 +175,19 @@ def setup_logging(
     Returns:
         Configured logger
     """
+    # Detect deployment context for install-type-aware defaults
+    if level == "INFO":  # Only override default, not explicit settings
+        from claude_mpm.core.unified_paths import DeploymentContext, PathContext
+
+        context = PathContext.detect_deployment_context()
+        if context in (
+            DeploymentContext.DEVELOPMENT,
+            DeploymentContext.EDITABLE_INSTALL,
+        ):
+            level = "INFO"  # Development: verbose logging
+        else:
+            level = "OFF"  # Production installs: silent by default
+
     logger = logging.getLogger(name)
 
     # Handle OFF level
@@ -201,19 +214,22 @@ def setup_logging(
 
     # Console handler
     if console_output:
+        # 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.
         if use_streaming:
             # Use streaming handler for single-line INFO messages
-            console_handler = StreamingHandler(sys.stdout)
+            console_handler = StreamingHandler(sys.stderr)
             console_handler.setFormatter(simple_formatter)
         elif use_rich and not json_format:
             # Rich support has been removed, use standard handler
-            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler = logging.StreamHandler(sys.stderr)
             console_handler.setFormatter(simple_formatter)
         else:
-            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler = logging.StreamHandler(sys.stderr)
             console_handler.setFormatter(formatter if json_format else simple_formatter)
 
-        console_handler.setLevel(logging.INFO)
+        console_handler.setLevel(log_level)  # Respect the requested log level
         logger.addHandler(console_handler)
 
     # File handler
@@ -250,7 +266,7 @@ def setup_logging(
                 if deleted_count > 0:
                     # Log to the new file handler that we're about to add
                     pass  # Deletion count will be logged when logger is ready
-            except Exception:
+            except Exception:  # nosec B110 - intentional: logging should not break app
                 pass  # Ignore cleanup errors
 
             # Also create a symlink to latest log (with thread safety)
@@ -292,7 +308,7 @@ def setup_logging(
                     # Fallback: try to create a regular file with reference to actual log
                     try:
                         latest_link.write_text(f"Latest log: {log_file.name}\n")
-                    except Exception:
+                    except Exception:  # nosec B110 - intentional: logging should not break app
                         pass  # Silently fail - logging should not break the application
                 except Exception as e:
                     # Catch any other unexpected errors to ensure logging doesn't break
@@ -368,15 +384,29 @@ def cleanup_old_mpm_logs(
             try:
                 log_file.unlink()
                 deleted_count += 1
-            except Exception:
+            except Exception:  # nosec B110 - intentional: log cleanup is best-effort
                 pass  # Ignore deletion errors
 
         return deleted_count
 
 
 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: