claude-mpm 5.6.17__py3-none-any.whl → 5.6.33__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.6.17
+5.6.33

claude_mpm/cli/commands/commander.py

@@ -43,12 +43,12 @@ def display_commander_banner():
 
     # Commander ASCII art banner
     banner = f"""
-{CYAN}╭{'─' * (width - 2)}╮{RESET}
-{CYAN}│{RESET}{BOLD}  ⚡ MPM Commander {RESET}{DIM}v{version}{RESET}{' ' * (width - 24 - len(version))}│
-{CYAN}│{RESET}{DIM}  Multi-Project AI Orchestration{RESET}{' ' * (width - 36)}│
-{CYAN}├{'─' * (width - 2)}┤{RESET}
-{CYAN}│{RESET}  {YELLOW}ALPHA{RESET} - APIs may change                                {' ' * (width - 55)}│
-{CYAN}╰{'─' * (width - 2)}╯{RESET}
+{CYAN}╭{"─" * (width - 2)}╮{RESET}
+{CYAN}│{RESET}{BOLD}  ⚡ MPM Commander {RESET}{DIM}v{version}{RESET}{" " * (width - 24 - len(version))}│
+{CYAN}│{RESET}{DIM}  Multi-Project AI Orchestration{RESET}{" " * (width - 36)}│
+{CYAN}├{"─" * (width - 2)}┤{RESET}
+{CYAN}│{RESET}  {YELLOW}ALPHA{RESET} - APIs may change                                {" " * (width - 55)}│
+{CYAN}╰{"─" * (width - 2)}╯{RESET}
 """
     print(banner)
 
@@ -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/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/cli/startup.py

@@ -34,13 +34,13 @@ def sync_hooks_on_startup(quiet: bool = False) -> bool:
         installer = HookInstaller()
 
         # Show brief status (hooks sync is fast)
-        if not quiet:
+        if not quiet and sys.stdout.isatty():
             print("Syncing Claude Code hooks...", end=" ", flush=True)
 
         # Reinstall hooks (force=True ensures update)
         success = installer.install_hooks(force=True)
 
-        if not quiet:
+        if not quiet and sys.stdout.isatty():
             if success:
                 print("✓")
             else:
@@ -49,7 +49,7 @@ def sync_hooks_on_startup(quiet: bool = False) -> bool:
         return success
 
     except Exception as e:
-        if not quiet:
+        if not quiet and sys.stdout.isatty():
             print("(error)")
         # Log but don't fail startup
         from ..core.logger import get_logger
@@ -280,11 +280,13 @@ def deploy_bundled_skills():
         if deployment_result.get("deployed"):
             # Show simple feedback for deployed skills
             deployed_count = len(deployment_result["deployed"])
-            print(f"✓ Bundled skills ready ({deployed_count} deployed)", flush=True)
+            if sys.stdout.isatty():
+                print(f"✓ Bundled skills ready ({deployed_count} deployed)", flush=True)
             logger.info(f"Skills: Deployed {deployed_count} skill(s)")
         elif not deployment_result.get("errors"):
             # No deployment needed, skills already present
-            print("✓ Bundled skills ready", flush=True)
+            if sys.stdout.isatty():
+                print("✓ Bundled skills ready", flush=True)
 
         if deployment_result.get("errors"):
             logger.warning(
@@ -318,7 +320,8 @@ def discover_and_link_runtime_skills():
 
         discover_skills()
         # Show simple success feedback
-        print("✓ Runtime skills linked", flush=True)
+        if sys.stdout.isatty():
+            print("✓ Runtime skills linked", flush=True)
     except Exception as e:
         # Import logger here to avoid circular imports
         from ..core.logger import get_logger
@@ -373,7 +376,8 @@ def deploy_output_style_on_startup():
 
         if all_up_to_date:
             # Show feedback that output styles are ready
-            print("✓ Output styles ready", flush=True)
+            if sys.stdout.isatty():
+                print("✓ Output styles ready", flush=True)
             return
 
         # Deploy all styles using the manager
@@ -383,7 +387,8 @@ def deploy_output_style_on_startup():
         deployed_count = sum(1 for success in results.values() if success)
 
         if deployed_count > 0:
-            print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
+            if sys.stdout.isatty():
+                print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
         else:
             # Deployment failed - log but don't fail startup
             from ..core.logger import get_logger
@@ -1290,9 +1295,11 @@ def verify_and_show_pm_skills():
         if result.verified:
             # Show verified status with count
             total_required = len(REQUIRED_PM_SKILLS)
-            print(
-                f"✓ PM skills: {total_required}/{total_required} verified", flush=True
-            )
+            if sys.stdout.isatty():
+                print(
+                    f"✓ PM skills: {total_required}/{total_required} verified",
+                    flush=True,
+                )
         else:
             # Show warning with details
             missing_count = len(result.missing_skills)
@@ -1311,13 +1318,15 @@ def verify_and_show_pm_skills():
             if "Auto-repaired" in result.message:
                 # Auto-repair succeeded
                 total_required = len(REQUIRED_PM_SKILLS)
-                print(
-                    f"✓ PM skills: {total_required}/{total_required} verified (auto-repaired)",
-                    flush=True,
-                )
+                if sys.stdout.isatty():
+                    print(
+                        f"✓ PM skills: {total_required}/{total_required} verified (auto-repaired)",
+                        flush=True,
+                    )
             else:
                 # Auto-repair failed or not attempted
-                print(f"⚠ PM skills: {status}", flush=True)
+                if sys.stdout.isatty():
+                    print(f"⚠ PM skills: {status}", flush=True)
 
                 # Log warnings for debugging
                 from ..core.logger import get_logger
@@ -1516,7 +1525,9 @@ def check_mcp_auto_configuration():
         from ..services.mcp_gateway.auto_configure import check_and_configure_mcp
 
         # Show progress feedback - this operation can take 10+ seconds
-        print("Checking MCP configuration...", end="", flush=True)
+        # Only show progress message in TTY mode to avoid interfering with Claude Code's status display
+        if sys.stdout.isatty():
+            print("Checking MCP configuration...", end="", flush=True)
 
         # This function handles all the logic:
         # - Checks if already configured
@@ -1527,11 +1538,17 @@ def check_mcp_auto_configuration():
         check_and_configure_mcp()
 
         # Clear the "Checking..." message by overwriting with spaces
-        print("\r" + " " * 30 + "\r", end="", flush=True)
+        # Only use carriage return clearing if stdout is a real TTY
+        if sys.stdout.isatty():
+            print("\r" + " " * 30 + "\r", end="", flush=True)
+        # In non-TTY mode, don't print anything - the "Checking..." message will just remain on its line
 
     except Exception as e:
         # Clear progress message on error
-        print("\r" + " " * 30 + "\r", end="", flush=True)
+        # Only use carriage return clearing if stdout is a real TTY
+        if sys.stdout.isatty():
+            print("\r" + " " * 30 + "\r", end="", flush=True)
+        # In non-TTY mode, don't print anything - the "Checking..." message will just remain on its line
 
         # Non-critical - log but don't fail
         from ..core.logger import get_logger

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/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/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/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/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/core/claude_runner.py

@@ -214,8 +214,12 @@ class ClaudeRunner:
             )
 
     def _get_deployment_state_path(self) -> Path:
-        """Get path to deployment state file."""
-        return Path.cwd() / ".claude-mpm" / "deployment-state.json"
+        """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.
@@ -331,18 +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
-            if self._check_deployment_state():
-                agents_dir = Path.cwd() / ".claude" / "agents"
-                agent_count = len(list(agents_dir.glob("*.md")))
-                print(f"✓ Agents: {agent_count} cached")
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        f"Agents already deployed: {agent_count} cached",
-                        level="INFO",
-                        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/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