claude-mpm 4.5.8__py3-none-any.whl → 4.5.12__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -26,6 +26,8 @@ from rich.syntax import Syntax
 from rich.table import Table
 from rich.text import Text
 
+from ...core.config import Config
+from ...services.mcp_config_manager import MCPConfigManager
 from ...services.version_service import VersionService
 from ...utils.console import console as default_console
 from ..shared import BaseCommand, CommandResult
@@ -54,18 +56,22 @@ class SimpleAgentManager:
         self.templates_dir = (
             Path(__file__).parent.parent.parent / "agents" / "templates"
         )
+        # Add logger for error reporting
+        import logging
+
+        self.logger = logging.getLogger(__name__)
 
     def _load_states(self):
         """Load agent states from file."""
         if self.config_file.exists():
-            with open(self.config_file) as f:
+            with self.config_file.open() as f:
                 self.states = json.load(f)
         else:
             self.states = {}
 
     def _save_states(self):
         """Save agent states to file."""
-        with open(self.config_file, "w") as f:
+        with self.config_file.open("w") as f:
             json.dump(self.states, f, indent=2)
 
     def is_agent_enabled(self, agent_name: str) -> bool:
@@ -99,7 +105,7 @@ class SimpleAgentManager:
                     continue
 
                 try:
-                    with open(template_file) as f:
+                    with template_file.open() as f:
                         template_data = json.load(f)
 
                     # Extract agent information from template
@@ -115,6 +121,9 @@ class SimpleAgentManager:
                     # Extract capabilities/tools as dependencies for display
                     capabilities = template_data.get("capabilities", {})
                     tools = capabilities.get("tools", [])
+                    # Ensure tools is a list before slicing
+                    if not isinstance(tools, list):
+                        tools = []
                     # Show first few tools as "dependencies" for UI purposes
                     display_tools = tools[:3] if len(tools) > 3 else tools
 
@@ -133,14 +142,24 @@ class SimpleAgentManager:
                         )
                     )
 
-                except (json.JSONDecodeError, KeyError):
-                    # Skip malformed templates
+                except (json.JSONDecodeError, KeyError) as e:
+                    # Log malformed templates but continue
+                    self.logger.debug(
+                        f"Skipping malformed template {template_file.name}: {e}"
+                    )
+                    continue
+                except Exception as e:
+                    # Log unexpected errors but continue processing other templates
+                    self.logger.debug(
+                        f"Error processing template {template_file.name}: {e}"
+                    )
                     continue
 
         except Exception as e:
-            # If there's an error reading templates, return a minimal set
+            # If there's a catastrophic error reading templates directory
+            self.logger.error(f"Failed to read templates directory: {e}")
             return [
-                AgentConfig("engineer", f"Error loading templates: {e!s}", []),
+                AgentConfig("engineer", f"Error accessing templates: {e!s}", []),
                 AgentConfig("research", "Research agent", []),
             ]
 
@@ -174,6 +193,7 @@ class ConfigureCommand(BaseCommand):
             getattr(args, "agents", False),
             getattr(args, "templates", False),
             getattr(args, "behaviors", False),
+            getattr(args, "startup", False),
             getattr(args, "version_info", False),
         ]
         if sum(nav_options) > 1:
@@ -185,7 +205,7 @@ class ConfigureCommand(BaseCommand):
 
         return None
 
-    def run(self, args) -> CommandResult:  # noqa: PLR0911
+    def run(self, args) -> CommandResult:
         """Execute the configure command."""
         # Set configuration scope
         self.current_scope = getattr(args, "scope", "project")
@@ -242,6 +262,9 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "behaviors", False):
             return self._run_behavior_management()
 
+        if getattr(args, "startup", False):
+            return self._run_startup_configuration()
+
         # Launch interactive TUI
         return self._run_interactive_tui(args)
 
@@ -263,8 +286,15 @@ class ConfigureCommand(BaseCommand):
                 elif choice == "3":
                     self._manage_behaviors()
                 elif choice == "4":
-                    self._switch_scope()
+                    # If user saves and wants to proceed to startup, exit the configurator
+                    if self._manage_startup_configuration():
+                        self.console.print(
+                            "\n[green]Configuration saved. Exiting configurator...[/green]"
+                        )
+                        break
                 elif choice == "5":
+                    self._switch_scope()
+                elif choice == "6":
                     self._show_version_info_interactive()
                 elif choice == "q":
                     self.console.print(
@@ -287,10 +317,14 @@ class ConfigureCommand(BaseCommand):
         """Display the TUI header."""
         self.console.clear()
 
+        # Get version for display
+        from claude_mpm import __version__
+
         # Create header panel
         header_text = Text()
         header_text.append("Claude MPM ", style="bold cyan")
         header_text.append("Configuration Interface", style="bold white")
+        header_text.append(f"\nv{__version__}", style="dim cyan")
 
         scope_text = Text(f"Scope: {self.current_scope.upper()}", style="yellow")
         dir_text = Text(f"Directory: {self.project_dir}", style="dim")
@@ -315,8 +349,13 @@ class ConfigureCommand(BaseCommand):
             ("1", "Agent Management", "Enable/disable agents and customize settings"),
             ("2", "Template Editing", "Edit agent JSON templates"),
             ("3", "Behavior Files", "Manage identity and workflow configurations"),
-            ("4", "Switch Scope", f"Current: {self.current_scope}"),
-            ("5", "Version Info", "Display MPM and Claude versions"),
+            (
+                "4",
+                "Startup Configuration",
+                "Configure MCP services and agents to start",
+            ),
+            ("5", "Switch Scope", f"Current: {self.current_scope}"),
+            ("6", "Version Info", "Display MPM and Claude versions"),
             ("q", "Quit", "Exit configuration interface"),
         ]
 
@@ -408,7 +447,7 @@ class ConfigureCommand(BaseCommand):
                 try:
                     template_path = self._get_agent_template_path(agent.name)
                     if template_path.exists():
-                        with open(template_path) as f:
+                        with template_path.open() as f:
                             template = json.load(f)
                         model = template.get("capabilities", {}).get("model", "default")
                         tools_display = f"Model: {model}"
@@ -503,7 +542,7 @@ class ConfigureCommand(BaseCommand):
         template_path = self._get_agent_template_path(agent.name)
 
         if template_path.exists():
-            with open(template_path) as f:
+            with template_path.open() as f:
                 template = json.load(f)
             is_system = str(template_path).startswith(
                 str(self.agent_manager.templates_dir)
@@ -654,11 +693,11 @@ class ConfigureCommand(BaseCommand):
             subprocess.call([editor, temp_path])
 
             # Read back the edited content
-            with open(temp_path) as f:
+            with temp_path.open() as f:
                 new_template = json.load(f)
 
             # Save to actual template path
-            with open(template_path, "w") as f:
+            with template_path.open("w") as f:
                 json.dump(new_template, f, indent=2)
 
             self.console.print("[green]Template updated successfully![/green]")
@@ -693,7 +732,7 @@ class ConfigureCommand(BaseCommand):
             current[parts[-1]] = value
 
             # Save the template
-            with open(template_path, "w") as f:
+            with template_path.open("w") as f:
                 json.dump(template, f, indent=2)
 
             self.console.print(
@@ -726,7 +765,7 @@ class ConfigureCommand(BaseCommand):
                 del current[parts[-1]]
 
                 # Save the template
-                with open(template_path, "w") as f:
+                with template_path.open("w") as f:
                     json.dump(template, f, indent=2)
 
                 self.console.print(
@@ -763,7 +802,7 @@ class ConfigureCommand(BaseCommand):
             return
 
         # Save the template copy
-        with open(custom_path, "w") as f:
+        with custom_path.open("w") as f:
             json.dump(template, f, indent=2)
 
         self.console.print(f"[green]Created custom template at: {custom_path}[/green]")
@@ -800,7 +839,7 @@ class ConfigureCommand(BaseCommand):
 
                 if template_path.exists():
                     try:
-                        with open(template_path) as f:
+                        with template_path.open() as f:
                             template = json.load(f)
 
                         # Extract additional information
@@ -979,6 +1018,537 @@ class ConfigureCommand(BaseCommand):
         self.console.print("[yellow]Behavior file export - Coming soon![/yellow]")
         Prompt.ask("Press Enter to continue")
 
+    def _manage_startup_configuration(self) -> bool:
+        """Manage startup configuration for MCP services and agents.
+
+        Returns:
+            bool: True if user saved and wants to proceed to startup, False otherwise
+        """
+        # Temporarily suppress INFO logging during Config initialization
+        import logging
+
+        root_logger = logging.getLogger("claude_mpm")
+        original_level = root_logger.level
+        root_logger.setLevel(logging.WARNING)
+
+        try:
+            # Load current configuration ONCE at the start
+            config = Config()
+            startup_config = self._load_startup_configuration(config)
+        finally:
+            # Restore original logging level
+            root_logger.setLevel(original_level)
+
+        proceed_to_startup = False
+        while True:
+            self.console.clear()
+            self._display_header()
+
+            self.console.print("[bold]Startup Configuration Management[/bold]\n")
+            self.console.print(
+                "[dim]Configure which MCP services, hook services, and system agents "
+                "are enabled when Claude MPM starts.[/dim]\n"
+            )
+
+            # Display current configuration (using in-memory state)
+            self._display_startup_configuration(startup_config)
+
+            # Show menu options
+            self.console.print("\n[bold]Options:[/bold]")
+            self.console.print("  [cyan]1[/cyan] - Configure MCP Services")
+            self.console.print("  [cyan]2[/cyan] - Configure Hook Services")
+            self.console.print("  [cyan]3[/cyan] - Configure System Agents")
+            self.console.print("  [cyan]4[/cyan] - Enable All")
+            self.console.print("  [cyan]5[/cyan] - Disable All")
+            self.console.print("  [cyan]6[/cyan] - Reset to Defaults")
+            self.console.print(
+                "  [cyan]s[/cyan] - Save configuration and start claude-mpm"
+            )
+            self.console.print("  [cyan]b[/cyan] - Cancel and return without saving")
+            self.console.print()
+
+            choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="s")
+
+            if choice == "b":
+                break
+            if choice == "1":
+                self._configure_mcp_services(startup_config, config)
+            elif choice == "2":
+                self._configure_hook_services(startup_config, config)
+            elif choice == "3":
+                self._configure_system_agents(startup_config, config)
+            elif choice == "4":
+                self._enable_all_services(startup_config, config)
+            elif choice == "5":
+                self._disable_all_services(startup_config, config)
+            elif choice == "6":
+                self._reset_to_defaults(startup_config, config)
+            elif choice == "s":
+                # Save and exit if successful
+                if self._save_startup_configuration(startup_config, config):
+                    proceed_to_startup = True
+                    break
+            else:
+                self.console.print("[red]Invalid choice.[/red]")
+                Prompt.ask("Press Enter to continue")
+
+        return proceed_to_startup
+
+    def _load_startup_configuration(self, config: Config) -> Dict:
+        """Load current startup configuration from config."""
+        startup_config = config.get("startup", {})
+
+        # Ensure all required sections exist
+        if "enabled_mcp_services" not in startup_config:
+            # Get available MCP services from MCPConfigManager
+            mcp_manager = MCPConfigManager()
+            available_services = list(mcp_manager.STATIC_MCP_CONFIGS.keys())
+            startup_config["enabled_mcp_services"] = available_services.copy()
+
+        if "enabled_hook_services" not in startup_config:
+            # Default hook services (health-monitor enabled by default)
+            startup_config["enabled_hook_services"] = [
+                "monitor",
+                "dashboard",
+                "response-logger",
+                "health-monitor",
+            ]
+
+        if "disabled_agents" not in startup_config:
+            # NEW LOGIC: Track DISABLED agents instead of enabled
+            # By default, NO agents are disabled (all agents enabled)
+            startup_config["disabled_agents"] = []
+
+        return startup_config
+
+    def _display_startup_configuration(self, startup_config: Dict) -> None:
+        """Display current startup configuration in a table."""
+        table = Table(
+            title="Current Startup Configuration", box=ROUNDED, show_lines=True
+        )
+
+        table.add_column("Category", style="cyan", width=20)
+        table.add_column("Enabled Services", style="white", width=50)
+        table.add_column("Count", style="dim", width=10)
+
+        # MCP Services
+        mcp_services = startup_config.get("enabled_mcp_services", [])
+        mcp_display = ", ".join(mcp_services[:3]) + (
+            "..." if len(mcp_services) > 3 else ""
+        )
+        table.add_row(
+            "MCP Services",
+            mcp_display if mcp_services else "[dim]None[/dim]",
+            str(len(mcp_services)),
+        )
+
+        # Hook Services
+        hook_services = startup_config.get("enabled_hook_services", [])
+        hook_display = ", ".join(hook_services[:3]) + (
+            "..." if len(hook_services) > 3 else ""
+        )
+        table.add_row(
+            "Hook Services",
+            hook_display if hook_services else "[dim]None[/dim]",
+            str(len(hook_services)),
+        )
+
+        # System Agents - show count of ENABLED agents (total - disabled)
+        all_agents = self.agent_manager.discover_agents() if self.agent_manager else []
+        disabled_agents = startup_config.get("disabled_agents", [])
+        enabled_count = len(all_agents) - len(disabled_agents)
+
+        # Show first few enabled agent names
+        enabled_names = [a.name for a in all_agents if a.name not in disabled_agents]
+        agent_display = ", ".join(enabled_names[:3]) + (
+            "..." if len(enabled_names) > 3 else ""
+        )
+        table.add_row(
+            "System Agents",
+            agent_display if enabled_names else "[dim]All Disabled[/dim]",
+            f"{enabled_count}/{len(all_agents)}",
+        )
+
+        self.console.print(table)
+
+    def _configure_mcp_services(self, startup_config: Dict, config: Config) -> None:
+        """Configure which MCP services to enable at startup."""
+        self.console.clear()
+        self._display_header()
+        self.console.print("[bold]Configure MCP Services[/bold]\n")
+
+        # Get available MCP services
+        mcp_manager = MCPConfigManager()
+        available_services = list(mcp_manager.STATIC_MCP_CONFIGS.keys())
+        enabled_services = set(startup_config.get("enabled_mcp_services", []))
+
+        # Display services with checkboxes
+        table = Table(box=ROUNDED, show_lines=True)
+        table.add_column("ID", style="dim", width=5)
+        table.add_column("Service", style="cyan", width=25)
+        table.add_column("Status", width=15)
+        table.add_column("Description", style="white", width=45)
+
+        service_descriptions = {
+            "kuzu-memory": "Graph-based memory system for agents",
+            "mcp-ticketer": "Ticket and issue tracking integration",
+            "mcp-browser": "Browser automation and web scraping",
+            "mcp-vector-search": "Semantic code search capabilities",
+        }
+
+        for idx, service in enumerate(available_services, 1):
+            status = (
+                "[green]✓ Enabled[/green]"
+                if service in enabled_services
+                else "[red]✗ Disabled[/red]"
+            )
+            description = service_descriptions.get(service, "MCP service")
+            table.add_row(str(idx), service, status, description)
+
+        self.console.print(table)
+        self.console.print("\n[bold]Commands:[/bold]")
+        self.console.print("  Enter service IDs to toggle (e.g., '1,3' or '1-4')")
+        self.console.print("  [cyan][a][/cyan] Enable all")
+        self.console.print("  [cyan][n][/cyan] Disable all")
+        self.console.print("  [cyan][b][/cyan] Back to previous menu")
+        self.console.print()
+
+        choice = Prompt.ask("[bold cyan]Toggle services[/bold cyan]", default="b")
+
+        if choice == "b":
+            return
+        if choice == "a":
+            startup_config["enabled_mcp_services"] = available_services.copy()
+            self.console.print("[green]All MCP services enabled![/green]")
+        elif choice == "n":
+            startup_config["enabled_mcp_services"] = []
+            self.console.print("[green]All MCP services disabled![/green]")
+        else:
+            # Parse service IDs
+            try:
+                selected_ids = self._parse_id_selection(choice, len(available_services))
+                for idx in selected_ids:
+                    service = available_services[idx - 1]
+                    if service in enabled_services:
+                        enabled_services.remove(service)
+                        self.console.print(f"[red]Disabled {service}[/red]")
+                    else:
+                        enabled_services.add(service)
+                        self.console.print(f"[green]Enabled {service}[/green]")
+                startup_config["enabled_mcp_services"] = list(enabled_services)
+            except (ValueError, IndexError) as e:
+                self.console.print(f"[red]Invalid selection: {e}[/red]")
+
+        Prompt.ask("Press Enter to continue")
+
+    def _configure_hook_services(self, startup_config: Dict, config: Config) -> None:
+        """Configure which hook services to enable at startup."""
+        self.console.clear()
+        self._display_header()
+        self.console.print("[bold]Configure Hook Services[/bold]\n")
+
+        # Available hook services
+        available_services = [
+            ("monitor", "Real-time event monitoring server (SocketIO)"),
+            ("dashboard", "Web-based dashboard interface"),
+            ("response-logger", "Agent response logging"),
+            ("health-monitor", "Service health and recovery monitoring"),
+        ]
+
+        enabled_services = set(startup_config.get("enabled_hook_services", []))
+
+        # Display services with checkboxes
+        table = Table(box=ROUNDED, show_lines=True)
+        table.add_column("ID", style="dim", width=5)
+        table.add_column("Service", style="cyan", width=25)
+        table.add_column("Status", width=15)
+        table.add_column("Description", style="white", width=45)
+
+        for idx, (service, description) in enumerate(available_services, 1):
+            status = (
+                "[green]✓ Enabled[/green]"
+                if service in enabled_services
+                else "[red]✗ Disabled[/red]"
+            )
+            table.add_row(str(idx), service, status, description)
+
+        self.console.print(table)
+        self.console.print("\n[bold]Commands:[/bold]")
+        self.console.print("  Enter service IDs to toggle (e.g., '1,3' or '1-4')")
+        self.console.print("  [cyan][a][/cyan] Enable all")
+        self.console.print("  [cyan][n][/cyan] Disable all")
+        self.console.print("  [cyan][b][/cyan] Back to previous menu")
+        self.console.print()
+
+        choice = Prompt.ask("[bold cyan]Toggle services[/bold cyan]", default="b")
+
+        if choice == "b":
+            return
+        if choice == "a":
+            startup_config["enabled_hook_services"] = [s[0] for s in available_services]
+            self.console.print("[green]All hook services enabled![/green]")
+        elif choice == "n":
+            startup_config["enabled_hook_services"] = []
+            self.console.print("[green]All hook services disabled![/green]")
+        else:
+            # Parse service IDs
+            try:
+                selected_ids = self._parse_id_selection(choice, len(available_services))
+                for idx in selected_ids:
+                    service = available_services[idx - 1][0]
+                    if service in enabled_services:
+                        enabled_services.remove(service)
+                        self.console.print(f"[red]Disabled {service}[/red]")
+                    else:
+                        enabled_services.add(service)
+                        self.console.print(f"[green]Enabled {service}[/green]")
+                startup_config["enabled_hook_services"] = list(enabled_services)
+            except (ValueError, IndexError) as e:
+                self.console.print(f"[red]Invalid selection: {e}[/red]")
+
+        Prompt.ask("Press Enter to continue")
+
+    def _configure_system_agents(self, startup_config: Dict, config: Config) -> None:
+        """Configure which system agents to deploy at startup.
+
+        NEW LOGIC: Uses disabled_agents list. All agents from templates are enabled by default.
+        """
+        while True:
+            self.console.clear()
+            self._display_header()
+            self.console.print("[bold]Configure System Agents[/bold]\n")
+            self.console.print(
+                "[dim]All agents discovered from templates are enabled by default. "
+                "Mark agents as disabled to prevent deployment.[/dim]\n"
+            )
+
+            # Discover available agents from template files
+            agents = self.agent_manager.discover_agents()
+            disabled_agents = set(startup_config.get("disabled_agents", []))
+
+            # Display agents with checkboxes
+            table = Table(box=ROUNDED, show_lines=True)
+            table.add_column("ID", style="dim", width=5)
+            table.add_column("Agent", style="cyan", width=25)
+            table.add_column("Status", width=15)
+            table.add_column("Description", style="white", width=45)
+
+            for idx, agent in enumerate(agents, 1):
+                # Agent is ENABLED if NOT in disabled list
+                is_enabled = agent.name not in disabled_agents
+                status = (
+                    "[green]✓ Enabled[/green]"
+                    if is_enabled
+                    else "[red]✗ Disabled[/red]"
+                )
+                desc_display = (
+                    agent.description[:42] + "..."
+                    if len(agent.description) > 42
+                    else agent.description
+                )
+                table.add_row(str(idx), agent.name, status, desc_display)
+
+            self.console.print(table)
+            self.console.print("\n[bold]Commands:[/bold]")
+            self.console.print("  Enter agent IDs to toggle (e.g., '1,3' or '1-4')")
+            self.console.print("  [cyan]a[/cyan] - Enable all (clear disabled list)")
+            self.console.print("  [cyan]n[/cyan] - Disable all")
+            self.console.print("  [cyan]b[/cyan] - Back to previous menu")
+            self.console.print()
+
+            choice = Prompt.ask("[bold cyan]Select option[/bold cyan]", default="b")
+
+            if choice == "b":
+                return
+            if choice == "a":
+                # Enable all = empty disabled list
+                startup_config["disabled_agents"] = []
+                self.console.print("[green]All agents enabled![/green]")
+                Prompt.ask("Press Enter to continue")
+            elif choice == "n":
+                # Disable all = all agents in disabled list
+                startup_config["disabled_agents"] = [agent.name for agent in agents]
+                self.console.print("[green]All agents disabled![/green]")
+                Prompt.ask("Press Enter to continue")
+            else:
+                # Parse agent IDs
+                try:
+                    selected_ids = self._parse_id_selection(choice, len(agents))
+                    for idx in selected_ids:
+                        agent = agents[idx - 1]
+                        if agent.name in disabled_agents:
+                            # Currently disabled, enable it (remove from disabled list)
+                            disabled_agents.remove(agent.name)
+                            self.console.print(f"[green]Enabled {agent.name}[/green]")
+                        else:
+                            # Currently enabled, disable it (add to disabled list)
+                            disabled_agents.add(agent.name)
+                            self.console.print(f"[red]Disabled {agent.name}[/red]")
+                    startup_config["disabled_agents"] = list(disabled_agents)
+                    # Refresh the display to show updated status immediately
+                except (ValueError, IndexError) as e:
+                    self.console.print(f"[red]Invalid selection: {e}[/red]")
+                    Prompt.ask("Press Enter to continue")
+
+    def _parse_id_selection(self, selection: str, max_id: int) -> List[int]:
+        """Parse ID selection string (e.g., '1,3,5' or '1-4')."""
+        ids = set()
+        parts = selection.split(",")
+
+        for part in parts:
+            part = part.strip()
+            if "-" in part:
+                # Range selection
+                start, end = part.split("-")
+                start_id = int(start.strip())
+                end_id = int(end.strip())
+                if start_id < 1 or end_id > max_id or start_id > end_id:
+                    raise ValueError(f"Invalid range: {part}")
+                ids.update(range(start_id, end_id + 1))
+            else:
+                # Single ID
+                id_num = int(part)
+                if id_num < 1 or id_num > max_id:
+                    raise ValueError(f"Invalid ID: {id_num}")
+                ids.add(id_num)
+
+        return sorted(ids)
+
+    def _enable_all_services(self, startup_config: Dict, config: Config) -> None:
+        """Enable all services and agents."""
+        if Confirm.ask("[yellow]Enable ALL services and agents?[/yellow]"):
+            # Enable all MCP services
+            mcp_manager = MCPConfigManager()
+            startup_config["enabled_mcp_services"] = list(
+                mcp_manager.STATIC_MCP_CONFIGS.keys()
+            )
+
+            # Enable all hook services
+            startup_config["enabled_hook_services"] = [
+                "monitor",
+                "dashboard",
+                "response-logger",
+                "health-monitor",
+            ]
+
+            # Enable all agents (empty disabled list)
+            startup_config["disabled_agents"] = []
+
+            self.console.print("[green]All services and agents enabled![/green]")
+            Prompt.ask("Press Enter to continue")
+
+    def _disable_all_services(self, startup_config: Dict, config: Config) -> None:
+        """Disable all services and agents."""
+        if Confirm.ask("[yellow]Disable ALL services and agents?[/yellow]"):
+            startup_config["enabled_mcp_services"] = []
+            startup_config["enabled_hook_services"] = []
+            # Disable all agents = add all to disabled list
+            agents = self.agent_manager.discover_agents()
+            startup_config["disabled_agents"] = [agent.name for agent in agents]
+
+            self.console.print("[green]All services and agents disabled![/green]")
+            self.console.print(
+                "[yellow]Note: You may need to enable at least some services for Claude MPM to function properly.[/yellow]"
+            )
+            Prompt.ask("Press Enter to continue")
+
+    def _reset_to_defaults(self, startup_config: Dict, config: Config) -> None:
+        """Reset startup configuration to defaults."""
+        if Confirm.ask("[yellow]Reset startup configuration to defaults?[/yellow]"):
+            # Reset to default values
+            mcp_manager = MCPConfigManager()
+            startup_config["enabled_mcp_services"] = list(
+                mcp_manager.STATIC_MCP_CONFIGS.keys()
+            )
+            startup_config["enabled_hook_services"] = [
+                "monitor",
+                "dashboard",
+                "response-logger",
+                "health-monitor",
+            ]
+            # Default: All agents enabled (empty disabled list)
+            startup_config["disabled_agents"] = []
+
+            self.console.print(
+                "[green]Startup configuration reset to defaults![/green]"
+            )
+            Prompt.ask("Press Enter to continue")
+
+    def _save_startup_configuration(self, startup_config: Dict, config: Config) -> bool:
+        """Save startup configuration to config file and return whether to proceed to startup.
+
+        Returns:
+            bool: True if should proceed to startup, False to continue in menu
+        """
+        try:
+            # Update the startup configuration
+            config.set("startup", startup_config)
+
+            # IMPORTANT: Also update agent_deployment.disabled_agents so the deployment
+            # system actually uses the configured disabled agents list
+            config.set(
+                "agent_deployment.disabled_agents",
+                startup_config.get("disabled_agents", []),
+            )
+
+            # Determine config file path
+            if self.current_scope == "project":
+                config_file = self.project_dir / ".claude-mpm" / "configuration.yaml"
+            else:
+                config_file = Path.home() / ".claude-mpm" / "configuration.yaml"
+
+            # Ensure directory exists
+            config_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Temporarily suppress INFO logging to avoid duplicate save messages
+            import logging
+
+            root_logger = logging.getLogger("claude_mpm")
+            original_level = root_logger.level
+            root_logger.setLevel(logging.WARNING)
+
+            try:
+                # Save configuration (this will log at INFO level which we've suppressed)
+                config.save(config_file, format="yaml")
+            finally:
+                # Restore original logging level
+                root_logger.setLevel(original_level)
+
+            self.console.print(
+                f"[green]✓ Startup configuration saved to {config_file}[/green]"
+            )
+            self.console.print(
+                "\n[cyan]Applying configuration and launching Claude MPM...[/cyan]\n"
+            )
+
+            # Launch claude-mpm run command to get full startup cycle
+            # This ensures:
+            # 1. Configuration is loaded
+            # 2. Enabled agents are deployed
+            # 3. Disabled agents are removed from .claude/agents/
+            # 4. MCP services and hooks are started
+            try:
+                # Use execvp to replace the current process with claude-mpm run
+                # This ensures a clean transition from configurator to Claude MPM
+                os.execvp("claude-mpm", ["claude-mpm", "run"])
+            except Exception as e:
+                self.console.print(
+                    f"[yellow]Could not launch Claude MPM automatically: {e}[/yellow]"
+                )
+                self.console.print(
+                    "[cyan]Please run 'claude-mpm' manually to start.[/cyan]"
+                )
+                Prompt.ask("Press Enter to continue")
+                return True
+
+            # This line will never be reached if execvp succeeds
+            return True
+
+        except Exception as e:
+            self.console.print(f"[red]Error saving configuration: {e}[/red]")
+            Prompt.ask("Press Enter to continue")
+            return False
+
     def _switch_scope(self) -> None:
         """Switch between project and user scope."""
         self.current_scope = "user" if self.current_scope == "project" else "project"
@@ -1105,7 +1675,7 @@ Directory: {self.project_dir}
 
             # Write to file
             output_path = Path(file_path)
-            with open(output_path, "w") as f:
+            with output_path.open("w") as f:
                 json.dump(config_data, f, indent=2)
 
             return CommandResult.success_result(
@@ -1122,7 +1692,7 @@ Directory: {self.project_dir}
             if not input_path.exists():
                 return CommandResult.error_result(f"File not found: {file_path}")
 
-            with open(input_path) as f:
+            with input_path.open() as f:
                 config_data = json.load(f)
 
             # Apply agent states
@@ -1377,6 +1947,20 @@ Directory: {self.project_dir}
         except Exception as e:
             return CommandResult.error_result(f"Behavior management failed: {e}")
 
+    def _run_startup_configuration(self) -> CommandResult:
+        """Jump directly to startup configuration."""
+        try:
+            proceed = self._manage_startup_configuration()
+            if proceed:
+                return CommandResult.success_result(
+                    "Startup configuration saved, proceeding to startup"
+                )
+            return CommandResult.success_result("Startup configuration completed")
+        except KeyboardInterrupt:
+            return CommandResult.success_result("Startup configuration cancelled")
+        except Exception as e:
+            return CommandResult.error_result(f"Startup configuration failed: {e}")
+
 
 def manage_configure(args) -> int:
     """Main entry point for configuration management command.