claude-mpm 5.6.18__tar.gz → 5.6.21__tar.gz

{claude_mpm-5.6.18/src/claude_mpm.egg-info → claude_mpm-5.6.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.6.18
+Version: 5.6.21
 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-5.6.18 → claude_mpm-5.6.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "5.6.18"
+version = "5.6.21"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -189,7 +189,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "5.6.18"
+version = "5.6.21"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-5.6.21/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+5.6.21

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/cli/commands/commander.py

@@ -142,7 +142,7 @@ def handle_commander_command(args) -> int:
         print()  # Blank line after loading
 
         # Get arguments
-        port = getattr(args, "port", 8765)
+        port = getattr(args, "port", 8766)  # NetworkPorts.COMMANDER_DEFAULT
         host = getattr(args, "host", "127.0.0.1")
         state_dir = getattr(args, "state_dir", None)
         no_chat = getattr(args, "no_chat", False) or getattr(args, "daemon_only", False)

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/cli/parsers/commander_parser.py

@@ -77,8 +77,8 @@ Examples:
     commander_parser.add_argument(
         "--port",
         type=int,
-        default=8765,
-        help="Port for internal services (default: 8765)",
+        default=8766,  # NetworkPorts.COMMANDER_DEFAULT
+        help="Port for internal services (default: 8766)",
     )
 
     # Optional: State directory

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/commander/chat/cli.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
@@ -26,20 +27,47 @@ load_env()
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class CommanderCLIConfig:
+    """Configuration for Commander CLI mode.
+
+    Attributes:
+        summarize_responses: Whether to use LLM to summarize instance responses
+        port: Port for internal services (reserved for future use)
+        state_dir: Directory for state persistence (optional)
+
+    Example:
+        >>> config = CommanderCLIConfig(summarize_responses=False)
+    """
+
+    summarize_responses: bool = True
+    port: int = 8765
+    state_dir: Optional[Path] = None
+
+
 async def run_commander(
     port: int = 8765,
     state_dir: Optional[Path] = None,
+    config: Optional[CommanderCLIConfig] = None,
 ) -> None:
     """Run Commander in interactive mode.
 
     Args:
         port: Port for internal services (unused currently).
         state_dir: Directory for state persistence (optional).
+        config: Commander CLI configuration (optional, uses defaults if None).
 
     Example:
         >>> asyncio.run(run_commander())
         # Starts interactive Commander REPL
+        >>> config = CommanderCLIConfig(summarize_responses=False)
+        >>> asyncio.run(run_commander(config=config))
+        # Starts Commander without response summarization
     """
+    # Use default config if not provided
+    if config is None:
+        config = CommanderCLIConfig(port=port, state_dir=state_dir)
+
     # Setup logging
     logging.basicConfig(
         level=logging.INFO,
@@ -61,8 +89,8 @@ async def run_commander(
     # Try to initialize LLM client (optional)
     llm_client: Optional[OpenRouterClient] = None
     try:
-        config = OpenRouterConfig()
-        llm_client = OpenRouterClient(config)
+        llm_config = OpenRouterConfig()
+        llm_client = OpenRouterClient(llm_config)
         logger.info("LLM client initialized")
     except ValueError as e:
         logger.warning(f"LLM client not available: {e}")
@@ -72,7 +100,14 @@ async def run_commander(
     output_relay: Optional[OutputRelay] = None
     if llm_client:
         try:
-            summarizer = OutputSummarizer(llm_client)
+            # Only create summarizer if summarize_responses is enabled
+            summarizer = None
+            if config.summarize_responses:
+                summarizer = OutputSummarizer(llm_client)
+                logger.info("Response summarization enabled")
+            else:
+                logger.info("Response summarization disabled")
+
             handler = OutputHandler(orchestrator, summarizer)
             formatter = OutputFormatter()
             output_relay = OutputRelay(handler, formatter)

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/commander/config.py

@@ -14,28 +14,30 @@ class DaemonConfig:
 
     Attributes:
         host: API server bind address
-        port: API server port
+        port: API server port (default: 8766 from NetworkPorts.COMMANDER_DEFAULT)
         log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
         state_dir: Directory for state persistence
         max_projects: Maximum concurrent projects
         healthcheck_interval: Healthcheck interval in seconds
         save_interval: State persistence interval in seconds
         poll_interval: Event polling interval in seconds
+        summarize_responses: Whether to use LLM to summarize instance responses
 
     Example:
-        >>> config = DaemonConfig(port=8765, log_level="DEBUG")
+        >>> config = DaemonConfig(port=8766, log_level="DEBUG")
         >>> config.state_dir
         PosixPath('/Users/user/.claude-mpm/commander')
     """
 
     host: str = "127.0.0.1"
-    port: int = 8765
+    port: int = 8766  # Default commander port (from network_config.NetworkPorts.COMMANDER_DEFAULT)
     log_level: str = "INFO"
     state_dir: Path = Path.home() / ".claude-mpm" / "commander"
     max_projects: int = 10
     healthcheck_interval: int = 30
     save_interval: int = 30
     poll_interval: float = 2.0
+    summarize_responses: bool = True
 
     def __post_init__(self):
         """Ensure state_dir is a Path object and create if needed."""

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/commander/daemon.py

@@ -307,7 +307,16 @@ class CommanderDaemon:
 
         Registers handlers for SIGINT and SIGTERM that trigger
         daemon shutdown via asyncio event loop.
+
+        Note: Signal handlers can only be registered from the main thread.
+        If called from a background thread, registration is skipped.
         """
+        import threading
+
+        # Signal handlers can only be registered from the main thread
+        if threading.current_thread() is not threading.main_thread():
+            logger.info("Running in background thread - signal handlers skipped")
+            return
 
         def handle_signal(signum: int, frame) -> None:
             """Handle shutdown signal.

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/commander/frameworks/base.py

@@ -19,6 +19,7 @@ class InstanceInfo:
         pane_target: Tmux pane target (e.g., "%1")
         git_branch: Current git branch if project is a git repo
         git_status: Git status summary if project is a git repo
+        connected: Whether instance has an active adapter connection
 
     Example:
         >>> info = InstanceInfo(
@@ -28,7 +29,8 @@ class InstanceInfo:
         ...     tmux_session="mpm-commander",
         ...     pane_target="%1",
         ...     git_branch="main",
-        ...     git_status="clean"
+        ...     git_status="clean",
+        ...     connected=True
         ... )
     """
 
@@ -39,6 +41,7 @@ class InstanceInfo:
     pane_target: str
     git_branch: Optional[str] = None
     git_status: Optional[str] = None
+    connected: bool = False
 
 
 class BaseFramework(ABC):

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/commander/instance_manager.py

@@ -167,6 +167,20 @@ class InstanceManager:
         startup_cmd = framework_obj.get_startup_command(project_path)
         self.orchestrator.send_keys(pane_target, startup_cmd)
 
+        # Create communication adapter for the instance (only for Claude Code for now)
+        # Do this BEFORE creating InstanceInfo so we can set connected=True
+        has_adapter = False
+        if framework == "cc":
+            runtime_adapter = ClaudeCodeAdapter()
+            comm_adapter = ClaudeCodeCommunicationAdapter(
+                orchestrator=self.orchestrator,
+                pane_target=pane_target,
+                runtime_adapter=runtime_adapter,
+            )
+            self._adapters[name] = comm_adapter
+            has_adapter = True
+            logger.debug(f"Created communication adapter for instance '{name}'")
+
         # Create instance info
         instance = InstanceInfo(
             name=name,
@@ -176,22 +190,12 @@ class InstanceManager:
             pane_target=pane_target,
             git_branch=git_branch,
             git_status=git_status,
+            connected=has_adapter,
         )
 
         # Track instance
         self._instances[name] = instance
 
-        # Create communication adapter for the instance (only for Claude Code for now)
-        if framework == "cc":
-            runtime_adapter = ClaudeCodeAdapter()
-            comm_adapter = ClaudeCodeCommunicationAdapter(
-                orchestrator=self.orchestrator,
-                pane_target=pane_target,
-                runtime_adapter=runtime_adapter,
-            )
-            self._adapters[name] = comm_adapter
-            logger.debug(f"Created communication adapter for instance '{name}'")
-
         logger.info(
             f"Started instance '{name}' with framework '{framework}' at {project_path}"
         )
@@ -226,6 +230,7 @@ class InstanceManager:
         # Remove adapter if exists
         if name in self._adapters:
             del self._adapters[name]
+            instance.connected = False
             logger.debug(f"Removed adapter for instance '{name}'")
 
         # Remove from tracking
@@ -335,3 +340,111 @@ class InstanceManager:
             ...         print(chunk, end='')
         """
         return self._adapters.get(name)
+
+    async def rename_instance(self, old_name: str, new_name: str) -> bool:
+        """Rename an instance.
+
+        Args:
+            old_name: Current instance name
+            new_name: New instance name
+
+        Returns:
+            True if renamed successfully
+
+        Raises:
+            InstanceNotFoundError: If old_name doesn't exist
+            InstanceAlreadyExistsError: If new_name already exists
+
+        Example:
+            >>> manager = InstanceManager(orchestrator)
+            >>> await manager.rename_instance("myapp", "myapp-v2")
+            True
+        """
+        # Validate old_name exists
+        if old_name not in self._instances:
+            raise InstanceNotFoundError(old_name)
+
+        # Validate new_name doesn't exist
+        if new_name in self._instances:
+            raise InstanceAlreadyExistsError(new_name)
+
+        # Get instance and update name
+        instance = self._instances[old_name]
+        instance.name = new_name
+
+        # Update _instances dict (remove old key, add new)
+        del self._instances[old_name]
+        self._instances[new_name] = instance
+
+        # Update _adapters dict if exists
+        if old_name in self._adapters:
+            adapter = self._adapters[old_name]
+            del self._adapters[old_name]
+            self._adapters[new_name] = adapter
+            logger.debug(f"Moved adapter from '{old_name}' to '{new_name}'")
+
+        logger.info(f"Renamed instance from '{old_name}' to '{new_name}'")
+
+        return True
+
+    async def close_instance(self, name: str) -> bool:
+        """Close and remove an instance.
+
+        Alias for stop_instance that provides clearer semantics for closing.
+
+        Args:
+            name: Instance name to close
+
+        Returns:
+            True if closed successfully
+
+        Raises:
+            InstanceNotFoundError: If instance not found
+
+        Example:
+            >>> manager = InstanceManager(orchestrator)
+            >>> await manager.close_instance("myapp")
+            True
+        """
+        return await self.stop_instance(name)
+
+    async def disconnect_instance(self, name: str) -> bool:
+        """Disconnect from an instance without closing it.
+
+        The instance keeps running but we stop communication.
+        Removes the adapter while keeping the instance tracked.
+
+        Args:
+            name: Instance name to disconnect from
+
+        Returns:
+            True if disconnected successfully
+
+        Raises:
+            InstanceNotFoundError: If instance not found
+
+        Example:
+            >>> manager = InstanceManager(orchestrator)
+            >>> await manager.disconnect_instance("myapp")
+            True
+            >>> # Instance still running, but no adapter connection
+            >>> adapter = manager.get_adapter("myapp")
+            >>> print(adapter)
+            None
+        """
+        # Validate instance exists
+        if name not in self._instances:
+            raise InstanceNotFoundError(name)
+
+        instance = self._instances[name]
+
+        # Remove adapter if exists (but keep instance)
+        if name in self._adapters:
+            # Could add cleanup here if adapter has resources to close
+            del self._adapters[name]
+            instance.connected = False
+            logger.info(f"Disconnected from instance '{name}' (instance still running)")
+        else:
+            logger.debug(f"No adapter to disconnect for instance '{name}'")
+
+        return True

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/core/claude_runner.py

@@ -335,19 +335,23 @@ class ClaudeRunner:
     def setup_agents(self) -> bool:
         """Deploy native agents to .claude/agents/."""
         try:
-            # Check if agents are already deployed and up-to-date
-            # This detects if reconciliation already ran during startup
-            if self._check_deployment_state():
-                agents_dir = Path.cwd() / ".claude" / "agents"
-                agent_count = len(list(agents_dir.glob("*.md")))
-                # Silent return - reconciliation already logged deployment
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        f"Agents already deployed via reconciliation: {agent_count} agents",
-                        level="DEBUG",
-                        component="deployment",
+            # 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"
                     )
-                return True
+                    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(

{claude_mpm-5.6.18 → claude_mpm-5.6.21}/src/claude_mpm/core/config.py

@@ -499,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": {
@@ -540,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
@@ -549,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-5.6.18 → claude_mpm-5.6.21}/src/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-5.6.18 → claude_mpm-5.6.21}/src/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-5.6.18 → claude_mpm-5.6.21}/src/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