claude-mpm 5.4.41__py3-none-any.whl → 5.6.72__py3-none-any.whl

claude_mpm/cli/commands/configure_agent_display.py

@@ -132,7 +132,9 @@ class AgentDisplay:
         self.console.print(table)
 
         # Display summary count
-        self.console.print(f"\n📊 Agents: {installed_count} Installed / {len(agents)} Total")
+        self.console.print(
+            f"\n📊 Agents: {installed_count} Installed / {len(agents)} Total"
+        )
 
     def display_agents_with_pending_states(self, agents: List[AgentConfig]) -> None:
         """Display agents table with pending state indicators.

claude_mpm/cli/commands/hook_errors.py

@@ -57,33 +57,33 @@ def list_errors(format, hook_type):
 
     if not errors:
         if hook_type:
-            click.echo(f"No errors recorded for hook type: {hook_type}")
+            click.echo(f"No errors recorded for hook type: {hook_type}", err=True)
         else:
-            click.echo("No errors recorded. Hook system is healthy! ✅")
+            click.echo("No errors recorded. Hook system is healthy! ✅", err=True)
         return
 
     if format == "json":
         # JSON output
-        click.echo(json.dumps(errors, indent=2))
+        click.echo(json.dumps(errors, indent=2), err=True)
     else:
         # Table output
-        click.echo("\n" + "=" * 80)
-        click.echo("Hook Error Memory Report")
-        click.echo("=" * 80)
+        click.echo("\n" + "=" * 80, err=True)
+        click.echo("Hook Error Memory Report", err=True)
+        click.echo("=" * 80, err=True)
 
         for key, data in errors.items():
-            click.echo(f"\n🔴 Error: {data['type']}")
-            click.echo(f"   Hook Type: {data['hook_type']}")
-            click.echo(f"   Details: {data['details']}")
-            click.echo(f"   Match: {data['match']}")
-            click.echo(f"   Count: {data['count']} occurrences")
-            click.echo(f"   First Seen: {data['first_seen']}")
-            click.echo(f"   Last Seen: {data['last_seen']}")
+            click.echo(f"\n🔴 Error: {data['type']}", err=True)
+            click.echo(f"   Hook Type: {data['hook_type']}", err=True)
+            click.echo(f"   Details: {data['details']}", err=True)
+            click.echo(f"   Match: {data['match']}", err=True)
+            click.echo(f"   Count: {data['count']} occurrences", err=True)
+            click.echo(f"   First Seen: {data['first_seen']}", err=True)
+            click.echo(f"   Last Seen: {data['last_seen']}", err=True)
 
-        click.echo("\n" + "=" * 80)
-        click.echo(f"Total unique errors: {len(errors)}")
-        click.echo(f"Memory file: {error_memory.memory_file}")
-        click.echo("\nTo clear errors: claude-mpm hook-errors clear")
+        click.echo("\n" + "=" * 80, err=True)
+        click.echo(f"Total unique errors: {len(errors)}", err=True)
+        click.echo(f"Memory file: {error_memory.memory_file}", err=True)
+        click.echo("\nTo clear errors: claude-mpm hook-errors clear", err=True)
 
 
 @hook_errors_group.command(name="summary")
@@ -99,28 +99,28 @@ def show_summary():
     summary = error_memory.get_error_summary()
 
     if summary["total_errors"] == 0:
-        click.echo("No errors recorded. Hook system is healthy! ✅")
+        click.echo("No errors recorded. Hook system is healthy! ✅", err=True)
         return
 
-    click.echo("\n" + "=" * 80)
-    click.echo("Hook Error Summary")
-    click.echo("=" * 80)
-    click.echo("\n📊 Statistics:")
-    click.echo(f"   Total Errors: {summary['total_errors']}")
-    click.echo(f"   Unique Errors: {summary['unique_errors']}")
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("Hook Error Summary", err=True)
+    click.echo("=" * 80, err=True)
+    click.echo("\n📊 Statistics:", err=True)
+    click.echo(f"   Total Errors: {summary['total_errors']}", err=True)
+    click.echo(f"   Unique Errors: {summary['unique_errors']}", err=True)
 
     if summary["errors_by_type"]:
-        click.echo("\n🔍 Errors by Type:")
+        click.echo("\n🔍 Errors by Type:", err=True)
         for error_type, count in summary["errors_by_type"].items():
-            click.echo(f"   {error_type}: {count}")
+            click.echo(f"   {error_type}: {count}", err=True)
 
     if summary["errors_by_hook"]:
-        click.echo("\n🎣 Errors by Hook Type:")
+        click.echo("\n🎣 Errors by Hook Type:", err=True)
         for hook_type, count in summary["errors_by_hook"].items():
-            click.echo(f"   {hook_type}: {count}")
+            click.echo(f"   {hook_type}: {count}", err=True)
 
-    click.echo(f"\n📁 Memory File: {summary['memory_file']}")
-    click.echo("\nFor detailed list: claude-mpm hook-errors list")
+    click.echo(f"\n📁 Memory File: {summary['memory_file']}", err=True)
+    click.echo("\nFor detailed list: claude-mpm hook-errors list", err=True)
 
 
 @hook_errors_group.command(name="clear")
@@ -158,21 +158,21 @@ def clear_errors(hook_type, yes):
         scope = "all hook types"
 
     if count == 0:
-        click.echo(f"No errors to clear {scope}.")
+        click.echo(f"No errors to clear {scope}.", err=True)
         return
 
     # Confirm if not using -y flag
     if not yes:
         message = f"Clear {count} error(s) {scope}?"
         if not click.confirm(message):
-            click.echo("Cancelled.")
+            click.echo("Cancelled.", err=True)
             return
 
     # Clear errors
     error_memory.clear_errors(hook_type)
 
-    click.echo(f"✅ Cleared {count} error(s) {scope}.")
-    click.echo("\nHooks will be retried on next execution.")
+    click.echo(f"✅ Cleared {count} error(s) {scope}.", err=True)
+    click.echo("\nHooks will be retried on next execution.", err=True)
 
 
 @hook_errors_group.command(name="diagnose")
@@ -201,19 +201,19 @@ def diagnose_errors(hook_type):
 
     if not errors:
         if hook_type:
-            click.echo(f"No errors to diagnose for hook type: {hook_type}")
+            click.echo(f"No errors to diagnose for hook type: {hook_type}", err=True)
         else:
-            click.echo("No errors to diagnose. Hook system is healthy! ✅")
+            click.echo("No errors to diagnose. Hook system is healthy! ✅", err=True)
         return
 
-    click.echo("\n" + "=" * 80)
-    click.echo("Hook Error Diagnostics")
-    click.echo("=" * 80)
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("Hook Error Diagnostics", err=True)
+    click.echo("=" * 80, err=True)
 
     for key, data in errors.items():
-        click.echo(f"\n🔴 Error: {data['type']}")
-        click.echo(f"   Hook: {data['hook_type']}")
-        click.echo(f"   Count: {data['count']} failures")
+        click.echo(f"\n🔴 Error: {data['type']}", err=True)
+        click.echo(f"   Hook: {data['hook_type']}", err=True)
+        click.echo(f"   Count: {data['count']} failures", err=True)
 
         # Generate and show fix suggestion
         error_info = {
@@ -223,13 +223,13 @@ def diagnose_errors(hook_type):
         }
         suggestion = error_memory.suggest_fix(error_info)
 
-        click.echo("\n" + "-" * 80)
-        click.echo(suggestion)
-        click.echo("-" * 80)
+        click.echo("\n" + "-" * 80, err=True)
+        click.echo(suggestion, err=True)
+        click.echo("-" * 80, err=True)
 
-    click.echo("\n" + "=" * 80)
-    click.echo("After fixing issues, clear errors to retry:")
-    click.echo("  claude-mpm hook-errors clear")
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("After fixing issues, clear errors to retry:", err=True)
+    click.echo("  claude-mpm hook-errors clear", err=True)
 
 
 @hook_errors_group.command(name="status")
@@ -244,27 +244,27 @@ def show_status():
     error_memory = get_hook_error_memory()
     summary = error_memory.get_error_summary()
 
-    click.echo("\n📊 Hook Error Memory Status")
-    click.echo("=" * 80)
+    click.echo("\n📊 Hook Error Memory Status", err=True)
+    click.echo("=" * 80, err=True)
 
     if summary["total_errors"] == 0:
-        click.echo("✅ Status: Healthy (no errors recorded)")
+        click.echo("✅ Status: Healthy (no errors recorded)", err=True)
     else:
-        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded")
-        click.echo(f"   Unique errors: {summary['unique_errors']}")
+        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded", err=True)
+        click.echo(f"   Unique errors: {summary['unique_errors']}", err=True)
 
         # Show which hooks are affected
         if summary["errors_by_hook"]:
             affected_hooks = list(summary["errors_by_hook"].keys())
-            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}")
+            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}", err=True)
 
-    click.echo(f"\n📁 Memory file: {summary['memory_file']}")
-    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}")
+    click.echo(f"\n📁 Memory file: {summary['memory_file']}", err=True)
+    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}", err=True)
 
-    click.echo("\nCommands:")
-    click.echo("  claude-mpm hook-errors list      # View detailed errors")
-    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions")
-    click.echo("  claude-mpm hook-errors clear     # Clear and retry")
+    click.echo("\nCommands:", err=True)
+    click.echo("  claude-mpm hook-errors list      # View detailed errors", err=True)
+    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions", err=True)
+    click.echo("  claude-mpm hook-errors clear     # Clear and retry", err=True)
 
 
 # Register the command group

claude_mpm/cli/commands/mcp.py

@@ -33,7 +33,27 @@ def manage_mcp(args):
     """
     logger = get_logger("cli.mcp")
 
-    # First check if MCP package is installed for any command
+    # Commands that don't require full MCP Gateway or mcp package
+    # These only need mcp_service_registry which doesn't require the mcp package
+    service_mgmt_commands = {
+        MCPCommands.ENABLE.value,
+        MCPCommands.DISABLE.value,
+        MCPCommands.LIST.value,
+    }
+
+    # Route service management commands directly without any MCP dependencies
+    if args.mcp_command in service_mgmt_commands:
+        try:
+            from .mcp_command_router import MCPCommandRouter
+
+            router = MCPCommandRouter(logger)
+            return router.route_command(args)
+        except Exception as e:
+            logger.error(f"Error running service command: {e}", exc_info=True)
+            print(f"Error: {e}")
+            return 1
+
+    # Now check for mcp package for other commands
     import importlib.util
 
     mcp_spec = importlib.util.find_spec("mcp")
@@ -58,22 +78,14 @@ def manage_mcp(args):
         except ImportError as e:
             # Provide minimal fallbacks for basic commands
             logger.warning(f"Some MCP Gateway services not available: {e}")
-
-            # Allow install command to proceed
-            if args.mcp_command == MCPCommands.INSTALL.value:
-                MCPConfiguration = None
-                MCPServiceRegistry = None
-                ToolRegistry = None
-                MCPGateway = None
-            else:
-                print(
-                    "\nError: MCP Gateway services not fully available",
-                    file=sys.stderr,
-                )
-                print(f"Details: {e}", file=sys.stderr)
-                print("\nTry running:", file=sys.stderr)
-                print("  claude-mpm mcp install", file=sys.stderr)
-                return 1
+            print(
+                "\nError: MCP Gateway services not fully available",
+                file=sys.stderr,
+            )
+            print(f"Details: {e}", file=sys.stderr)
+            print("\nTry running:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
+            return 1
 
         if not args.mcp_command:
             # No subcommand - show status by default

claude_mpm/cli/commands/mcp_command_router.py

@@ -48,6 +48,15 @@ class MCPCommandRouter:
         if args.mcp_command == MCPCommands.EXTERNAL.value:
             return self._manage_external(args)
 
+        if args.mcp_command == MCPCommands.ENABLE.value:
+            return self._enable_service(args)
+
+        if args.mcp_command == MCPCommands.DISABLE.value:
+            return self._disable_service(args)
+
+        if args.mcp_command == MCPCommands.LIST.value:
+            return self._list_services(args)
+
         if args.mcp_command == "cleanup":
             return self._cleanup_locks(args)
 
@@ -134,6 +143,27 @@ class MCPCommandRouter:
         handler = MCPExternalCommands(self.logger)
         return handler.manage_external(args)
 
+    def _enable_service(self, args) -> int:
+        """Enable MCP service command handler."""
+        from .mcp_service_commands import MCPServiceCommands
+
+        handler = MCPServiceCommands(self.logger)
+        return handler.enable_service(args)
+
+    def _disable_service(self, args) -> int:
+        """Disable MCP service command handler."""
+        from .mcp_service_commands import MCPServiceCommands
+
+        handler = MCPServiceCommands(self.logger)
+        return handler.disable_service(args)
+
+    def _list_services(self, args) -> int:
+        """List MCP services command handler."""
+        from .mcp_service_commands import MCPServiceCommands
+
+        handler = MCPServiceCommands(self.logger)
+        return handler.list_services(args)
+
     def _show_help(self):
         """Show available MCP commands."""
         print("\nAvailable MCP commands:")
@@ -148,6 +178,10 @@ class MCPCommandRouter:
         print("  config   - View and manage configuration")
         print("  external - Manage external MCP services")
         print("  cleanup  - Clean up legacy files")
+        print("\nService management:")
+        print("  enable   - Enable an MCP service in configuration")
+        print("  disable  - Disable an MCP service from configuration")
+        print("  list     - List available and enabled MCP services")
         print("\nFor help with a specific command:")
         print("  claude-mpm mcp <command> --help")
         print("\nExamples:")
@@ -159,3 +193,8 @@ class MCPCommandRouter:
         print("  claude-mpm mcp tools")
         print("  claude-mpm mcp register my-tool")
         print("  claude-mpm mcp test my-tool")
+        print("\nService management examples:")
+        print("  claude-mpm mcp list --available       # List all available services")
+        print("  claude-mpm mcp enable kuzu-memory     # Enable a service")
+        print("  claude-mpm mcp enable mcp-github --interactive  # Enable with prompts")
+        print("  claude-mpm mcp disable mcp-github     # Disable a service")

claude_mpm/cli/commands/mcp_service_commands.py

@@ -0,0 +1,304 @@
+"""MCP service management commands for claude-mpm CLI.
+
+This module provides enable, disable, and list operations for MCP services
+using the service registry for configuration generation.
+
+WHY: Enables users to easily enable/disable MCP services with proper
+credential handling and configuration management.
+"""
+
+import getpass
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from argparse import Namespace
+    from logging import Logger
+
+
+class MCPServiceCommands:
+    """Command handlers for MCP service management."""
+
+    # Configuration file paths
+    GLOBAL_CONFIG = Path.home() / ".claude.json"
+    PROJECT_CONFIG = Path(".mcp.json")
+
+    def __init__(self, logger: "Logger") -> None:
+        """Initialize the command handler.
+
+        Args:
+            logger: Logger instance for output
+        """
+        self.logger = logger
+
+    def enable_service(self, args: "Namespace") -> int:
+        """Enable an MCP service in configuration.
+
+        Args:
+            args: Parsed command arguments with:
+                - service_name: Name of service to enable
+                - interactive: Whether to prompt for credentials
+                - env: List of KEY=VALUE strings
+                - use_global: Use global config instead of project
+
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        from ...services.mcp_service_registry import MCPServiceRegistry
+
+        service_name = args.service_name
+
+        # Check if service exists in registry
+        service = MCPServiceRegistry.get(service_name)
+        if not service:
+            available = MCPServiceRegistry.list_names()
+            print(f"Error: Unknown service '{service_name}'")
+            print(f"Available services: {', '.join(available)}")
+            return 1
+
+        # Parse environment variables from --env flags
+        env_vars: dict[str, str] = {}
+        if args.env:
+            for env_str in args.env:
+                if "=" not in env_str:
+                    print(f"Error: Invalid env format '{env_str}'. Use KEY=VALUE")
+                    return 1
+                key, value = env_str.split("=", 1)
+                env_vars[key] = value
+
+        # Interactive mode: prompt for required env vars
+        if args.interactive:
+            for var in service.required_env:
+                if var not in env_vars:
+                    # Use getpass for sensitive values (tokens, keys, etc.)
+                    if any(
+                        keyword in var.upper()
+                        for keyword in [
+                            "TOKEN",
+                            "KEY",
+                            "SECRET",
+                            "PASSWORD",
+                            "CREDENTIAL",
+                        ]
+                    ):
+                        value = getpass.getpass(f"Enter {var}: ")
+                    else:
+                        value = input(f"Enter {var}: ")
+                    if value:
+                        env_vars[var] = value
+
+        # Validate required environment variables
+        is_valid, missing = MCPServiceRegistry.validate_env(service, env_vars)
+        if not is_valid:
+            print(
+                f"Error: Missing required environment variables: {', '.join(missing)}"
+            )
+            print(f"Use --env {missing[0]}=VALUE or --interactive to provide them")
+            return 1
+
+        # Generate service configuration
+        config = MCPServiceRegistry.generate_config(service, env_vars)
+
+        # Determine config file path
+        config_path = self.GLOBAL_CONFIG if args.use_global else self.PROJECT_CONFIG
+
+        # Load existing config or create new
+        existing_config = self._load_config(config_path)
+
+        # Add/update service in mcpServers section
+        if "mcpServers" not in existing_config:
+            existing_config["mcpServers"] = {}
+
+        existing_config["mcpServers"][service_name] = config
+
+        # Save configuration
+        if self._save_config(config_path, existing_config):
+            location = (
+                "global (~/.claude.json)" if args.use_global else "project (.mcp.json)"
+            )
+            print(f"Enabled '{service_name}' in {location}")
+            print(f"Description: {service.description}")
+
+            if service.optional_env:
+                print(
+                    f"\nOptional environment variables: {', '.join(service.optional_env)}"
+                )
+                print("Use --env VAR=VALUE to set them")
+
+            return 0
+        print(f"Error: Failed to save configuration to {config_path}")
+        return 1
+
+    def disable_service(self, args: "Namespace") -> int:
+        """Disable an MCP service from configuration.
+
+        This removes the service from the configuration file but does NOT
+        uninstall the underlying package.
+
+        Args:
+            args: Parsed command arguments with:
+                - service_name: Name of service to disable
+                - use_global: Use global config instead of project
+
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        service_name = args.service_name
+        config_path = self.GLOBAL_CONFIG if args.use_global else self.PROJECT_CONFIG
+
+        # Load existing config
+        existing_config = self._load_config(config_path)
+
+        # Check if service exists in config
+        if "mcpServers" not in existing_config:
+            print(f"Error: No MCP services configured in {config_path}")
+            return 1
+
+        if service_name not in existing_config["mcpServers"]:
+            print(f"Error: Service '{service_name}' is not enabled")
+            enabled = list(existing_config["mcpServers"].keys())
+            if enabled:
+                print(f"Enabled services: {', '.join(enabled)}")
+            return 1
+
+        # Remove service from config
+        del existing_config["mcpServers"][service_name]
+
+        # Save configuration
+        if self._save_config(config_path, existing_config):
+            location = (
+                "global (~/.claude.json)" if args.use_global else "project (.mcp.json)"
+            )
+            print(f"Disabled '{service_name}' in {location}")
+            print(
+                "Note: The package is still installed. Use pipx/uvx to uninstall if needed."
+            )
+            return 0
+        print(f"Error: Failed to save configuration to {config_path}")
+        return 1
+
+    def list_services(self, args: "Namespace") -> int:
+        """List MCP services (available and/or enabled).
+
+        Args:
+            args: Parsed command arguments with:
+                - available: Show all available services from registry
+                - enabled: Show only enabled services
+                - use_global: Check global config instead of project
+                - verbose: Show detailed information
+
+        Returns:
+            Exit code (0 for success)
+        """
+        from ...services.mcp_service_registry import MCPServiceRegistry
+
+        config_path = self.GLOBAL_CONFIG if args.use_global else self.PROJECT_CONFIG
+        existing_config = self._load_config(config_path)
+        enabled_services = existing_config.get("mcpServers", {})
+
+        # Default: show both available and enabled
+        show_available = args.available or not (args.available or args.enabled)
+        show_enabled = args.enabled or not (args.available or args.enabled)
+
+        if show_available:
+            print("Available MCP Services:")
+            print("-" * 60)
+            for service in MCPServiceRegistry.list_all():
+                status = "[enabled]" if service.name in enabled_services else ""
+                default_marker = " (default)" if service.enabled_by_default else ""
+                print(f"  {service.name:<25} {status:>10}{default_marker}")
+                if args.verbose:
+                    print(f"    Description: {service.description}")
+                    print(f"    Package: {service.package}")
+                    print(f"    Install: {service.install_method.value}")
+                    if service.required_env:
+                        print(f"    Required env: {', '.join(service.required_env)}")
+                    if service.optional_env:
+                        print(f"    Optional env: {', '.join(service.optional_env)}")
+                    print()
+            print()
+
+        if show_enabled:
+            location = (
+                "global (~/.claude.json)" if args.use_global else "project (.mcp.json)"
+            )
+            print(f"Enabled Services ({location}):")
+            print("-" * 60)
+            if not enabled_services:
+                print("  No services enabled")
+            else:
+                for name, config in enabled_services.items():
+                    registry_service = MCPServiceRegistry.get(name)
+                    if registry_service:
+                        print(f"  {name:<25} [registered]")
+                        if args.verbose:
+                            print(f"    Description: {registry_service.description}")
+                    else:
+                        print(f"  {name:<25} [custom]")
+                    if args.verbose:
+                        print(f"    Command: {config.get('command', 'N/A')}")
+                        if "args" in config:
+                            print(f"    Args: {config['args']}")
+                        if "env" in config:
+                            # Mask sensitive values
+                            env_display = {}
+                            for k, v in config.get("env", {}).items():
+                                if any(
+                                    keyword in k.upper()
+                                    for keyword in [
+                                        "TOKEN",
+                                        "KEY",
+                                        "SECRET",
+                                        "PASSWORD",
+                                    ]
+                                ):
+                                    env_display[k] = "***"
+                                else:
+                                    env_display[k] = v
+                            print(f"    Env: {env_display}")
+                        print()
+
+        return 0
+
+    def _load_config(self, path: Path) -> dict:
+        """Load configuration from a JSON file.
+
+        Args:
+            path: Path to the configuration file
+
+        Returns:
+            Configuration dictionary (empty if file doesn't exist)
+        """
+        if not path.exists():
+            return {}
+        try:
+            with open(path) as f:
+                data = json.load(f)
+                return dict(data) if isinstance(data, dict) else {}
+        except json.JSONDecodeError as e:
+            self.logger.warning(f"Invalid JSON in {path}: {e}")
+            return {}
+        except OSError as e:
+            self.logger.warning(f"Failed to read {path}: {e}")
+            return {}
+
+    def _save_config(self, path: Path, config: dict) -> bool:
+        """Save configuration to a JSON file.
+
+        Args:
+            path: Path to the configuration file
+            config: Configuration dictionary to save
+
+        Returns:
+            True if saved successfully, False otherwise
+        """
+        try:
+            # Ensure parent directory exists
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with open(path, "w") as f:
+                json.dump(config, f, indent=2)
+            return True
+        except OSError as e:
+            self.logger.error(f"Failed to write {path}: {e}")
+            return False

claude_mpm/cli/commands/monitor.py

@@ -118,7 +118,7 @@ class MonitorCommand(BaseCommand):
                 # Check if it's actually running
                 if not self.daemon.lifecycle.is_running():
                     return CommandResult.error_result(
-                        "Monitor daemon failed to start. Check ~/.claude-mpm/monitor-daemon.log for details."
+                        "Monitor daemon failed to start. Check ~/.claude-mpm/logs/monitor-daemon-*.log for details."
                     )
 
                 # Get the actual PID
@@ -146,7 +146,7 @@ class MonitorCommand(BaseCommand):
             pass
 
         return CommandResult.error_result(
-            "Failed to start unified monitor daemon. Check ~/.claude-mpm/monitor-daemon.log for details."
+            "Failed to start unified monitor daemon. Check ~/.claude-mpm/logs/monitor-daemon-*.log for details."
         )
 
     def _stop_monitor(self, args) -> CommandResult: