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

claude_mpm/cli/commands/configure.py

@@ -12,153 +12,53 @@ DESIGN DECISIONS:
 """
 
 import json
-import os
-import sys
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from rich.box import ROUNDED
-from rich.columns import Columns
+import questionary
+from questionary import Style
 from rich.console import Console
-from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
-from rich.syntax import Syntax
-from rich.table import Table
 from rich.text import Text
 
+from ...core.config import Config
 from ...services.version_service import VersionService
+from ...utils.agent_filters import apply_all_filters, get_deployed_agent_ids
 from ...utils.console import console as default_console
 from ..shared import BaseCommand, CommandResult
-
-
-class AgentConfig:
-    """Simple agent configuration model."""
-
-    def __init__(
-        self, name: str, description: str = "", dependencies: Optional[List[str]] = None
-    ):
-        self.name = name
-        self.description = description
-        self.dependencies = dependencies or []
-
-
-class SimpleAgentManager:
-    """Simple agent state management that discovers real agents from templates."""
-
-    def __init__(self, config_dir: Path):
-        self.config_dir = config_dir
-        self.config_file = config_dir / "agent_states.json"
-        self.config_dir.mkdir(parents=True, exist_ok=True)
-        self._load_states()
-        # Path to agent templates directory
-        self.templates_dir = (
-            Path(__file__).parent.parent.parent / "agents" / "templates"
-        )
-
-    def _load_states(self):
-        """Load agent states from file."""
-        if self.config_file.exists():
-            with open(self.config_file) 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:
-            json.dump(self.states, f, indent=2)
-
-    def is_agent_enabled(self, agent_name: str) -> bool:
-        """Check if an agent is enabled."""
-        return self.states.get(agent_name, {}).get("enabled", True)
-
-    def set_agent_enabled(self, agent_name: str, enabled: bool):
-        """Set agent enabled state."""
-        if agent_name not in self.states:
-            self.states[agent_name] = {}
-        self.states[agent_name]["enabled"] = enabled
-        self._save_states()
-
-    def discover_agents(self) -> List[AgentConfig]:
-        """Discover available agents from template JSON files."""
-        agents = []
-
-        # Scan templates directory for JSON files
-        if not self.templates_dir.exists():
-            # Fallback to a minimal set if templates dir doesn't exist
-            return [
-                AgentConfig("engineer", "Engineering agent (templates not found)", []),
-                AgentConfig("research", "Research agent (templates not found)", []),
-            ]
-
-        try:
-            # Read all JSON template files
-            for template_file in sorted(self.templates_dir.glob("*.json")):
-                # Skip backup files
-                if "backup" in template_file.name.lower():
-                    continue
-
-                try:
-                    with open(template_file) as f:
-                        template_data = json.load(f)
-
-                    # Extract agent information from template
-                    agent_id = template_data.get("agent_id", template_file.stem)
-
-                    # Get metadata for display info
-                    metadata = template_data.get("metadata", {})
-                    metadata.get("name", agent_id)
-                    description = metadata.get(
-                        "description", "No description available"
-                    )
-
-                    # Extract capabilities/tools as dependencies for display
-                    capabilities = template_data.get("capabilities", {})
-                    tools = capabilities.get("tools", [])
-                    # Show first few tools as "dependencies" for UI purposes
-                    display_tools = tools[:3] if len(tools) > 3 else tools
-
-                    # Normalize agent ID (remove -agent suffix if present, replace underscores)
-                    normalized_id = agent_id.replace("-agent", "").replace("_", "-")
-
-                    agents.append(
-                        AgentConfig(
-                            name=normalized_id,
-                            description=(
-                                description[:80] + "..."
-                                if len(description) > 80
-                                else description
-                            ),
-                            dependencies=display_tools,
-                        )
-                    )
-
-                except (json.JSONDecodeError, KeyError):
-                    # Skip malformed templates
-                    continue
-
-        except Exception as e:
-            # If there's an error reading templates, return a minimal set
-            return [
-                AgentConfig("engineer", f"Error loading templates: {e!s}", []),
-                AgentConfig("research", "Research agent", []),
-            ]
-
-        # Sort agents by name for consistent display
-        agents.sort(key=lambda a: a.name)
-
-        return (
-            agents
-            if agents
-            else [
-                AgentConfig("engineer", "No agents found in templates", []),
-            ]
-        )
+from .agent_state_manager import SimpleAgentManager
+from .configure_agent_display import AgentDisplay
+from .configure_behavior_manager import BehaviorManager
+from .configure_hook_manager import HookManager
+from .configure_models import AgentConfig
+from .configure_navigation import ConfigNavigation
+from .configure_persistence import ConfigPersistence
+from .configure_startup_manager import StartupManager
+from .configure_template_editor import TemplateEditor
+from .configure_validators import (
+    parse_id_selection,
+    validate_args as validate_configure_args,
+)
 
 
 class ConfigureCommand(BaseCommand):
     """Interactive configuration management command."""
 
+    # Questionary style optimized for dark terminals (WCAG AAA compliant)
+    QUESTIONARY_STYLE = Style(
+        [
+            ("selected", "fg:#e0e0e0 bold"),  # Light gray - excellent readability
+            ("pointer", "fg:#ffd700 bold"),  # Gold/yellow - highly visible pointer
+            ("highlighted", "fg:#e0e0e0"),  # Light gray - clear hover state
+            ("question", "fg:#e0e0e0 bold"),  # Light gray bold - prominent questions
+            ("checkbox", "fg:#00ff00"),  # Green - for checked boxes
+            (
+                "checkbox-selected",
+                "fg:#00ff00 bold",
+            ),  # Green bold - for checked selected boxes
+        ]
+    )
+
     def __init__(self):
         super().__init__("configure")
         self.console = default_console
@@ -166,24 +66,88 @@ class ConfigureCommand(BaseCommand):
         self.current_scope = "project"
         self.project_dir = Path.cwd()
         self.agent_manager = None
+        self.hook_manager = HookManager(self.console)
+        self.behavior_manager = None  # Initialized when scope is set
+        self._agent_display = None  # Lazy-initialized
+        self._persistence = None  # Lazy-initialized
+        self._navigation = None  # Lazy-initialized
+        self._template_editor = None  # Lazy-initialized
+        self._startup_manager = None  # Lazy-initialized
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
-        # Check for conflicting direct navigation options
-        nav_options = [
-            getattr(args, "agents", False),
-            getattr(args, "templates", False),
-            getattr(args, "behaviors", False),
-            getattr(args, "version_info", False),
-        ]
-        if sum(nav_options) > 1:
-            return "Only one direct navigation option can be specified at a time"
-
-        # Check for conflicting non-interactive options
-        if getattr(args, "enable_agent", None) and getattr(args, "disable_agent", None):
-            return "Cannot enable and disable agents at the same time"
-
-        return None
+        return validate_configure_args(args)
+
+    @property
+    def agent_display(self) -> AgentDisplay:
+        """Lazy-initialize agent display handler."""
+        if self._agent_display is None:
+            if self.agent_manager is None:
+                raise RuntimeError(
+                    "agent_manager must be initialized before agent_display"
+                )
+            self._agent_display = AgentDisplay(
+                self.console,
+                self.agent_manager,
+                self._get_agent_template_path,
+                self._display_header,
+            )
+        return self._agent_display
+
+    @property
+    def persistence(self) -> ConfigPersistence:
+        """Lazy-initialize persistence handler."""
+        if self._persistence is None:
+            # Note: agent_manager might be None for version_info calls
+            self._persistence = ConfigPersistence(
+                self.console,
+                self.version_service,
+                self.agent_manager,  # Can be None for version operations
+                self._get_agent_template_path,
+                self._display_header,
+                self.current_scope,
+                self.project_dir,
+            )
+        return self._persistence
+
+    @property
+    def navigation(self) -> ConfigNavigation:
+        """Lazy-initialize navigation handler."""
+        if self._navigation is None:
+            self._navigation = ConfigNavigation(self.console, self.project_dir)
+            # Sync scope from main command
+            self._navigation.current_scope = self.current_scope
+        return self._navigation
+
+    @property
+    def template_editor(self) -> TemplateEditor:
+        """Lazy-initialize template editor."""
+        if self._template_editor is None:
+            if self.agent_manager is None:
+                raise RuntimeError(
+                    "agent_manager must be initialized before template_editor"
+                )
+            self._template_editor = TemplateEditor(
+                self.console, self.agent_manager, self.current_scope, self.project_dir
+            )
+        return self._template_editor
+
+    @property
+    def startup_manager(self) -> StartupManager:
+        """Lazy-initialize startup manager."""
+        if self._startup_manager is None:
+            if self.agent_manager is None:
+                raise RuntimeError(
+                    "agent_manager must be initialized before startup_manager"
+                )
+            self._startup_manager = StartupManager(
+                self.agent_manager,
+                self.console,
+                self.current_scope,
+                self.project_dir,
+                self._display_header,
+            )
+        return self._startup_manager
 
     def run(self, args) -> CommandResult:
         """Execute the configure command."""
@@ -192,12 +156,15 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "project_dir", None):
             self.project_dir = Path(args.project_dir)
 
-        # Initialize agent manager with appropriate config directory
+        # Initialize agent manager and behavior manager with appropriate config directory
         if self.current_scope == "project":
             config_dir = self.project_dir / ".claude-mpm"
         else:
             config_dir = Path.home() / ".claude-mpm"
         self.agent_manager = SimpleAgentManager(config_dir)
+        self.behavior_manager = BehaviorManager(
+            config_dir, self.current_scope, self.console
+        )
 
         # Disable colors if requested
         if getattr(args, "no_colors", False):
@@ -242,39 +209,15 @@ 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)
 
     def _run_interactive_tui(self, args) -> CommandResult:
-        """Run the main interactive TUI."""
-        # Check if we can use the modern Textual TUI
-        use_textual = getattr(args, "use_textual", True)
-        force_rich = getattr(args, "force_rich", False)
-
-        if use_textual and not force_rich:
-            try:
-                # Try to import and use Textual TUI
-                from .configure_tui import can_use_tui, launch_tui
-
-                if can_use_tui():
-                    self.console.print(
-                        "[cyan]Launching full-screen configuration interface...[/cyan]"
-                    )
-                    return launch_tui(self.current_scope, self.project_dir)
-                # Fall back to Rich TUI if terminal doesn't support full-screen
-                self.console.print(
-                    "[yellow]Terminal doesn't support full-screen mode. Using menu interface.[/yellow]"
-                )
-            except ImportError:
-                # Textual not available, fall back to Rich
-                self.console.print(
-                    "[yellow]Textual not installed. Using menu interface.[/yellow]"
-                )
-                self.console.print(
-                    "[dim]Install textual for a better experience: pip install textual[/dim]"
-                )
-
-        # Original Rich-based TUI
+        """Run the main interactive menu interface."""
+        # Rich-based menu interface
         try:
             self.console.clear()
 
@@ -286,13 +229,49 @@ class ConfigureCommand(BaseCommand):
                 if choice == "1":
                     self._manage_agents()
                 elif choice == "2":
-                    self._edit_templates()
+                    self._manage_skills()
                 elif choice == "3":
-                    self._manage_behaviors()
+                    self._edit_templates()
                 elif choice == "4":
-                    self._switch_scope()
+                    self._manage_behaviors()
                 elif choice == "5":
+                    # 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 == "6":
+                    self._switch_scope()
+                elif choice == "7":
                     self._show_version_info_interactive()
+                elif choice == "l":
+                    # Check for pending agent changes
+                    if self.agent_manager and self.agent_manager.has_pending_changes():
+                        should_save = Confirm.ask(
+                            "[yellow]You have unsaved agent changes. Save them before launching?[/yellow]",
+                            default=True,
+                        )
+                        if should_save:
+                            self.agent_manager.commit_deferred_changes()
+                            self.console.print("[green]✓ Agent changes saved[/green]")
+                        else:
+                            self.agent_manager.discard_deferred_changes()
+                            self.console.print(
+                                "[yellow]⚠ Agent changes discarded[/yellow]"
+                            )
+
+                    # Save all configuration
+                    self.console.print("\n[cyan]Saving configuration...[/cyan]")
+                    if self._save_all_configuration():
+                        # Launch Claude MPM (this will replace the process if successful)
+                        self._launch_claude_mpm()
+                        # If execvp fails, we'll return here and break
+                        break
+                    self.console.print(
+                        "[red]✗ Failed to save configuration. Not launching.[/red]"
+                    )
+                    Prompt.ask("\nPress Enter to continue")
                 elif choice == "q":
                     self.console.print(
                         "\n[green]Configuration complete. Goodbye![/green]"
@@ -312,777 +291,504 @@ class ConfigureCommand(BaseCommand):
 
     def _display_header(self) -> None:
         """Display the TUI header."""
-        self.console.clear()
-
-        # Create header panel
-        header_text = Text()
-        header_text.append("Claude MPM ", style="bold cyan")
-        header_text.append("Configuration Interface", style="bold white")
-
-        scope_text = Text(f"Scope: {self.current_scope.upper()}", style="yellow")
-        dir_text = Text(f"Directory: {self.project_dir}", style="dim")
-
-        header_content = Columns([header_text], align="center")
-        subtitle_content = f"{scope_text} | {dir_text}"
-
-        header_panel = Panel(
-            header_content,
-            subtitle=subtitle_content,
-            box=ROUNDED,
-            style="blue",
-            padding=(1, 2),
-        )
-
-        self.console.print(header_panel)
-        self.console.print()
+        # Sync scope to navigation before display
+        self.navigation.current_scope = self.current_scope
+        self.navigation.display_header()
 
     def _show_main_menu(self) -> str:
         """Show the main menu and get user choice."""
-        menu_items = [
-            ("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"),
-            ("q", "Quit", "Exit configuration interface"),
-        ]
-
-        table = Table(show_header=False, box=None, padding=(0, 2))
-        table.add_column("Key", style="cyan", width=3)
-        table.add_column("Option", style="bold white", width=20)
-        table.add_column("Description", style="dim")
-
-        for key, option, desc in menu_items:
-            table.add_row(f"[{key}]", option, desc)
-
-        menu_panel = Panel(
-            table, title="[bold]Main Menu[/bold]", box=ROUNDED, style="green"
-        )
-
-        self.console.print(menu_panel)
-        self.console.print()
-
-        return Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="q")
+        # Sync scope to navigation before display
+        self.navigation.current_scope = self.current_scope
+        return self.navigation.show_main_menu()
 
     def _manage_agents(self) -> None:
-        """Agent management interface."""
+        """Enhanced agent management with remote agent discovery and installation."""
         while True:
             self.console.clear()
-            self._display_header()
-
-            # Display available agents
-            agents = self.agent_manager.discover_agents()
-            self._display_agents_table(agents)
-
-            # Show agent menu
-            self.console.print("\n[bold]Agent Management Options:[/bold]")
-            self.console.print("  [cyan][e][/cyan] Enable an agent")
-            self.console.print("  [cyan][d][/cyan] Disable an agent")
-            self.console.print("  [cyan][c][/cyan] Customize agent template")
-            self.console.print("  [cyan][v][/cyan] View agent details")
-            self.console.print("  [cyan][r][/cyan] Reset agent to defaults")
-            self.console.print("  [cyan][b][/cyan] Back to main menu")
-            self.console.print()
+            self.navigation.display_header()
+            self.console.print("\n[bold blue]═══ Agent Management ═══[/bold blue]\n")
+
+            # Step 1: Show configured sources
+            self.console.print("[bold white]═══ Agent Sources ═══[/bold white]\n")
+
+            sources = self._get_configured_sources()
+            if sources:
+                from rich.table import Table
+
+                sources_table = Table(show_header=True, header_style="bold white")
+                sources_table.add_column(
+                    "Source",
+                    style="bright_yellow",
+                    width=40,
+                    no_wrap=True,
+                    overflow="ellipsis",
+                )
+                sources_table.add_column(
+                    "Status", style="green", width=15, no_wrap=True
+                )
+                sources_table.add_column(
+                    "Agents", style="yellow", width=10, no_wrap=True
+                )
 
-            choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="b")
+                for source in sources:
+                    status = "✓ Active" if source.get("enabled", True) else "Disabled"
+                    agent_count = source.get("agent_count", "?")
+                    sources_table.add_row(
+                        source["identifier"], status, str(agent_count)
+                    )
 
-            if choice == "b":
-                break
-            if choice == "e":
-                self._enable_agent_interactive(agents)
-            elif choice == "d":
-                self._disable_agent_interactive(agents)
-            elif choice == "c":
-                self._customize_agent_template(agents)
-            elif choice == "v":
-                self._view_agent_details(agents)
-            elif choice == "r":
-                self._reset_agent_defaults(agents)
+                self.console.print(sources_table)
             else:
-                self.console.print("[red]Invalid choice.[/red]")
-                Prompt.ask("Press Enter to continue")
-
-    def _display_agents_table(self, agents: List[AgentConfig]) -> None:
-        """Display a table of available agents."""
-        table = Table(
-            title=f"Available Agents ({len(agents)} total)",
-            box=ROUNDED,
-            show_lines=True,
-        )
-
-        table.add_column("ID", style="dim", width=3)
-        table.add_column("Name", style="cyan", width=22)
-        table.add_column("Status", width=12)
-        table.add_column("Description", style="white", width=45)
-        table.add_column("Model/Tools", style="dim", width=20)
-
-        for idx, agent in enumerate(agents, 1):
-            # Check if agent is enabled
-            is_enabled = self.agent_manager.is_agent_enabled(agent.name)
-            status = (
-                "[green]✓ Enabled[/green]" if is_enabled else "[red]✗ Disabled[/red]"
-            )
+                self.console.print("[yellow]No agent sources configured[/yellow]")
+                self.console.print(
+                    "[dim]Default source 'bobmatnyc/claude-mpm-agents' will be used[/dim]\n"
+                )
 
-            # Format tools/dependencies - show first 2 tools
-            tools_display = ""
-            if agent.dependencies:
-                if len(agent.dependencies) > 2:
-                    tools_display = f"{', '.join(agent.dependencies[:2])}..."
-                else:
-                    tools_display = ", ".join(agent.dependencies)
-            else:
-                # Try to get model from template
-                try:
-                    template_path = self._get_agent_template_path(agent.name)
-                    if template_path.exists():
-                        with open(template_path) as f:
-                            template = json.load(f)
-                        model = template.get("capabilities", {}).get("model", "default")
-                        tools_display = f"Model: {model}"
-                    else:
-                        tools_display = "Default"
-                except:
-                    tools_display = "Default"
-
-            # Truncate description for table display
-            desc_display = (
-                agent.description[:42] + "..."
-                if len(agent.description) > 42
-                else agent.description
-            )
+            # Step 2: Discover and display available agents
+            self.console.print("\n[bold white]═══ Available Agents ═══[/bold white]\n")
 
-            table.add_row(str(idx), agent.name, status, desc_display, tools_display)
+            try:
+                # Discover agents (includes both local and remote)
+                agents = self.agent_manager.discover_agents(include_remote=True)
 
-        self.console.print(table)
+                # Set deployment status on each agent for display
+                deployed_ids = get_deployed_agent_ids()
+                for agent in agents:
+                    # Extract leaf name for comparison
+                    agent_leaf_name = agent.name.split("/")[-1]
+                    agent.is_deployed = agent_leaf_name in deployed_ids
 
-    def _enable_agent_interactive(self, agents: List[AgentConfig]) -> None:
-        """Interactive agent enabling."""
-        agent_id = Prompt.ask("Enter agent ID to enable (or 'all' for all agents)")
+                # Filter BASE_AGENT from display (1M-502 Phase 1)
+                agents = self._filter_agent_configs(agents, filter_deployed=False)
 
-        if agent_id.lower() == "all":
-            if Confirm.ask("[yellow]Enable ALL agents?[/yellow]"):
-                for agent in agents:
-                    self.agent_manager.set_agent_enabled(agent.name, True)
-                self.console.print("[green]All agents enabled successfully![/green]")
-        else:
-            try:
-                idx = int(agent_id) - 1
-                if 0 <= idx < len(agents):
-                    agent = agents[idx]
-                    self.agent_manager.set_agent_enabled(agent.name, True)
+                if not agents:
+                    self.console.print("[yellow]No agents found[/yellow]")
                     self.console.print(
-                        f"[green]Agent '{agent.name}' enabled successfully![/green]"
+                        "[dim]Configure sources with 'claude-mpm agent-source add'[/dim]\n"
                     )
                 else:
-                    self.console.print("[red]Invalid agent ID.[/red]")
-            except ValueError:
-                self.console.print("[red]Invalid input. Please enter a number.[/red]")
-
-        Prompt.ask("Press Enter to continue")
+                    # Display agents in a table (already filtered at line 339)
+                    self._display_agents_with_source_info(agents)
 
-    def _disable_agent_interactive(self, agents: List[AgentConfig]) -> None:
-        """Interactive agent disabling."""
-        agent_id = Prompt.ask("Enter agent ID to disable (or 'all' for all agents)")
+            except Exception as e:
+                self.console.print(f"[red]Error discovering agents: {e}[/red]")
+                self.logger.error(f"Agent discovery failed: {e}", exc_info=True)
 
-        if agent_id.lower() == "all":
-            if Confirm.ask("[yellow]Disable ALL agents?[/yellow]"):
-                for agent in agents:
-                    self.agent_manager.set_agent_enabled(agent.name, False)
-                self.console.print("[green]All agents disabled successfully![/green]")
-        else:
+            # Step 3: Menu options with arrow-key navigation
+            self.console.print()
             try:
-                idx = int(agent_id) - 1
-                if 0 <= idx < len(agents):
-                    agent = agents[idx]
-                    self.agent_manager.set_agent_enabled(agent.name, False)
-                    self.console.print(
-                        f"[green]Agent '{agent.name}' disabled successfully![/green]"
-                    )
-                else:
-                    self.console.print("[red]Invalid agent ID.[/red]")
-            except ValueError:
-                self.console.print("[red]Invalid input. Please enter a number.[/red]")
-
-        Prompt.ask("Press Enter to continue")
+                choice = questionary.select(
+                    "Agent Management:",
+                    choices=[
+                        "Manage sources (add/remove repositories)",
+                        "Select Agents",
+                        "Install preset (predefined sets)",
+                        "Remove agents",
+                        "View agent details",
+                        "Toggle agents (legacy enable/disable)",
+                        questionary.Separator(),
+                        "← Back to main menu",
+                    ],
+                    style=self.QUESTIONARY_STYLE,
+                ).ask()
+
+                if choice is None or choice == "← Back to main menu":
+                    break
 
-    def _customize_agent_template(self, agents: List[AgentConfig]) -> None:
-        """Customize agent JSON template."""
-        agent_id = Prompt.ask("Enter agent ID to customize")
+                agents_var = agents if "agents" in locals() else []
+
+                # Map selection to action
+                if choice == "Manage sources (add/remove repositories)":
+                    self._manage_sources()
+                elif choice == "Select Agents":
+                    self._deploy_agents_individual(agents_var)
+                elif choice == "Install preset (predefined sets)":
+                    self._deploy_agents_preset()
+                elif choice == "Remove agents":
+                    self._remove_agents(agents_var)
+                elif choice == "View agent details":
+                    self._view_agent_details_enhanced(agents_var)
+                elif choice == "Toggle agents (legacy enable/disable)":
+                    self._toggle_agents_interactive(agents_var)
+
+            except KeyboardInterrupt:
+                self.console.print("\n[yellow]Operation cancelled[/yellow]")
+                break
 
-        try:
-            idx = int(agent_id) - 1
-            if 0 <= idx < len(agents):
-                agent = agents[idx]
-                self._edit_agent_template(agent)
-            else:
-                self.console.print("[red]Invalid agent ID.[/red]")
-                Prompt.ask("Press Enter to continue")
-        except ValueError:
-            self.console.print("[red]Invalid input. Please enter a number.[/red]")
-            Prompt.ask("Press Enter to continue")
+    def _display_agents_table(self, agents: List[AgentConfig]) -> None:
+        """Display a table of available agents."""
+        self.agent_display.display_agents_table(agents)
 
-    def _edit_agent_template(self, agent: AgentConfig) -> None:
-        """Edit an agent's JSON template."""
-        self.console.clear()
-        self.console.print(f"[bold]Editing template for: {agent.name}[/bold]\n")
+    def _display_agents_with_pending_states(self, agents: List[AgentConfig]) -> None:
+        """Display agents table with pending state indicators."""
+        self.agent_display.display_agents_with_pending_states(agents)
 
-        # Get current template
-        template_path = self._get_agent_template_path(agent.name)
+    def _toggle_agents_interactive(self, agents: List[AgentConfig]) -> None:
+        """Interactive multi-agent enable/disable with batch save."""
 
-        if template_path.exists():
-            with open(template_path) as f:
-                template = json.load(f)
-            is_system = str(template_path).startswith(
-                str(self.agent_manager.templates_dir)
-            )
-        else:
-            # Create a minimal template structure based on system templates
-            template = {
-                "schema_version": "1.2.0",
-                "agent_id": agent.name,
-                "agent_version": "1.0.0",
-                "agent_type": agent.name.replace("-", "_"),
-                "metadata": {
-                    "name": agent.name.replace("-", " ").title() + " Agent",
-                    "description": agent.description,
-                    "tags": [agent.name],
-                    "author": "Custom",
-                    "created_at": "",
-                    "updated_at": "",
-                },
-                "capabilities": {
-                    "model": "opus",
-                    "tools": (
-                        agent.dependencies
-                        if agent.dependencies
-                        else ["Read", "Write", "Edit", "Bash"]
-                    ),
-                },
-                "instructions": {
-                    "base_template": "BASE_AGENT_TEMPLATE.md",
-                    "custom_instructions": "",
-                },
-            }
-            is_system = False
-
-        # Display current template
-        if is_system:
-            self.console.print(
-                "[yellow]Viewing SYSTEM template (read-only). Customization will create a local copy.[/yellow]\n"
-            )
+        # Initialize pending states from current states
+        for agent in agents:
+            current_state = self.agent_manager.is_agent_enabled(agent.name)
+            self.agent_manager.set_agent_enabled_deferred(agent.name, current_state)
 
-        self.console.print("[bold]Current Template:[/bold]")
-        # Truncate for display if too large
-        display_template = template.copy()
-        if (
-            "instructions" in display_template
-            and isinstance(display_template["instructions"], dict)
-            and (
-                "custom_instructions" in display_template["instructions"]
-                and len(str(display_template["instructions"]["custom_instructions"]))
-                > 200
-            )
-        ):
-            display_template["instructions"]["custom_instructions"] = (
-                display_template["instructions"]["custom_instructions"][:200] + "..."
+        while True:
+            # Display table with pending states
+            self._display_agents_with_pending_states(agents)
+
+            # Show menu
+            self.console.print("\n[bold]Toggle Agent Status:[/bold]")
+            text_toggle = Text("  ")
+            text_toggle.append("[t]", style="bold blue")
+            text_toggle.append(" Enter agent IDs to toggle (e.g., '1,3,5' or '1-4')")
+            self.console.print(text_toggle)
+
+            text_all = Text("  ")
+            text_all.append("[a]", style="bold blue")
+            text_all.append(" Enable all agents")
+            self.console.print(text_all)
+
+            text_none = Text("  ")
+            text_none.append("[n]", style="bold blue")
+            text_none.append(" Disable all agents")
+            self.console.print(text_none)
+
+            text_save = Text("  ")
+            text_save.append("[s]", style="bold green")
+            text_save.append(" Save changes and return")
+            self.console.print(text_save)
+
+            text_cancel = Text("  ")
+            text_cancel.append("[c]", style="bold magenta")
+            text_cancel.append(" Cancel (discard changes)")
+            self.console.print(text_cancel)
+
+            choice = (
+                Prompt.ask("[bold blue]Select an option[/bold blue]", default="s")
+                .strip()
+                .lower()
             )
 
-        json_str = json.dumps(display_template, indent=2)
-        # Limit display to first 50 lines for readability
-        lines = json_str.split("\n")
-        if len(lines) > 50:
-            json_str = "\n".join(lines[:50]) + "\n... (truncated for display)"
-
-        syntax = Syntax(json_str, "json", theme="monokai", line_numbers=True)
-        self.console.print(syntax)
-        self.console.print()
-
-        # Editing options
-        self.console.print("[bold]Editing Options:[/bold]")
-        if not is_system:
-            self.console.print("  [cyan][1][/cyan] Edit in external editor")
-            self.console.print("  [cyan][2][/cyan] Add/modify a field")
-            self.console.print("  [cyan][3][/cyan] Remove a field")
-            self.console.print("  [cyan][4][/cyan] Reset to defaults")
-        else:
-            self.console.print("  [cyan][1][/cyan] Create customized copy")
-            self.console.print("  [cyan][2][/cyan] View full template")
-        self.console.print("  [cyan][b][/cyan] Back")
-        self.console.print()
+            if choice == "s":
+                if self.agent_manager.has_pending_changes():
+                    self.agent_manager.commit_deferred_changes()
+                    self.console.print("[green]✓ Changes saved successfully![/green]")
+                else:
+                    self.console.print("[yellow]No changes to save.[/yellow]")
+                Prompt.ask("Press Enter to continue")
+                break
+            if choice == "c":
+                self.agent_manager.discard_deferred_changes()
+                self.console.print("[yellow]Changes discarded.[/yellow]")
+                Prompt.ask("Press Enter to continue")
+                break
+            if choice == "a":
+                for agent in agents:
+                    self.agent_manager.set_agent_enabled_deferred(agent.name, True)
+            elif choice == "n":
+                for agent in agents:
+                    self.agent_manager.set_agent_enabled_deferred(agent.name, False)
+            elif choice == "t" or choice.replace(",", "").replace("-", "").isdigit():
+                selected_ids = self._parse_id_selection(
+                    choice if choice != "t" else Prompt.ask("Enter IDs"), len(agents)
+                )
+                for idx in selected_ids:
+                    if 1 <= idx <= len(agents):
+                        agent = agents[idx - 1]
+                        current = self.agent_manager.get_pending_state(agent.name)
+                        self.agent_manager.set_agent_enabled_deferred(
+                            agent.name, not current
+                        )
 
-        choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="b")
+    def _customize_agent_template(self, agents: List[AgentConfig]) -> None:
+        """Customize agent JSON template."""
+        self.template_editor.customize_agent_template(agents)
 
-        if is_system:
-            if choice == "1":
-                # Create a customized copy
-                self._create_custom_template_copy(agent, template)
-            elif choice == "2":
-                # View full template
-                self._view_full_template(template)
-        elif choice == "1":
-            self._edit_in_external_editor(template_path, template)
-        elif choice == "2":
-            self._modify_template_field(template, template_path)
-        elif choice == "3":
-            self._remove_template_field(template, template_path)
-        elif choice == "4":
-            self._reset_template(agent, template_path)
-
-        if choice != "b":
-            Prompt.ask("Press Enter to continue")
+    def _edit_agent_template(self, agent: AgentConfig) -> None:
+        """Edit an agent's JSON template."""
+        self.template_editor.edit_agent_template(agent)
 
     def _get_agent_template_path(self, agent_name: str) -> Path:
         """Get the path to an agent's template file."""
-        # First check for custom template in project/user config
-        if self.current_scope == "project":
-            config_dir = self.project_dir / ".claude-mpm" / "agents"
-        else:
-            config_dir = Path.home() / ".claude-mpm" / "agents"
-
-        config_dir.mkdir(parents=True, exist_ok=True)
-        custom_template = config_dir / f"{agent_name}.json"
-
-        # If custom template exists, return it
-        if custom_template.exists():
-            return custom_template
-
-        # Otherwise, look for the system template
-        # Handle various naming conventions
-        possible_names = [
-            f"{agent_name}.json",
-            f"{agent_name.replace('-', '_')}.json",
-            f"{agent_name}-agent.json",
-            f"{agent_name.replace('-', '_')}_agent.json",
-        ]
-
-        for name in possible_names:
-            system_template = self.agent_manager.templates_dir / name
-            if system_template.exists():
-                return system_template
-
-        # Return the custom template path for new templates
-        return custom_template
+        return self.template_editor.get_agent_template_path(agent_name)
 
     def _edit_in_external_editor(self, template_path: Path, template: Dict) -> None:
         """Open template in external editor."""
-        import subprocess
-        import tempfile
-
-        # Write current template to temp file
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
-            json.dump(template, f, indent=2)
-            temp_path = f.name
-
-        # Get editor from environment
-        editor = os.environ.get("EDITOR", "nano")
-
-        try:
-            # Open in editor
-            subprocess.call([editor, temp_path])
-
-            # Read back the edited content
-            with open(temp_path) as f:
-                new_template = json.load(f)
-
-            # Save to actual template path
-            with open(template_path, "w") as f:
-                json.dump(new_template, f, indent=2)
-
-            self.console.print("[green]Template updated successfully![/green]")
-
-        except Exception as e:
-            self.console.print(f"[red]Error editing template: {e}[/red]")
-        finally:
-            # Clean up temp file
-            Path(temp_path).unlink(missing_ok=True)
+        self.template_editor.edit_in_external_editor(template_path, template)
 
     def _modify_template_field(self, template: Dict, template_path: Path) -> None:
         """Add or modify a field in the template."""
-        field_name = Prompt.ask(
-            "Enter field name (use dot notation for nested, e.g., 'config.timeout')"
-        )
-        field_value = Prompt.ask("Enter field value (JSON format)")
-
-        try:
-            # Parse the value as JSON
-            value = json.loads(field_value)
-
-            # Navigate to the field location
-            parts = field_name.split(".")
-            current = template
-
-            for part in parts[:-1]:
-                if part not in current:
-                    current[part] = {}
-                current = current[part]
-
-            # Set the value
-            current[parts[-1]] = value
-
-            # Save the template
-            with open(template_path, "w") as f:
-                json.dump(template, f, indent=2)
-
-            self.console.print(
-                f"[green]Field '{field_name}' updated successfully![/green]"
-            )
-
-        except json.JSONDecodeError:
-            self.console.print("[red]Invalid JSON value. Please try again.[/red]")
-        except Exception as e:
-            self.console.print(f"[red]Error updating field: {e}[/red]")
+        self.template_editor.modify_template_field(template, template_path)
 
     def _remove_template_field(self, template: Dict, template_path: Path) -> None:
         """Remove a field from the template."""
-        field_name = Prompt.ask(
-            "Enter field name to remove (use dot notation for nested)"
-        )
-
-        try:
-            # Navigate to the field location
-            parts = field_name.split(".")
-            current = template
-
-            for part in parts[:-1]:
-                if part not in current:
-                    raise KeyError(f"Field '{field_name}' not found")
-                current = current[part]
-
-            # Remove the field
-            if parts[-1] in current:
-                del current[parts[-1]]
-
-                # Save the template
-                with open(template_path, "w") as f:
-                    json.dump(template, f, indent=2)
-
-                self.console.print(
-                    f"[green]Field '{field_name}' removed successfully![/green]"
-                )
-            else:
-                self.console.print(f"[red]Field '{field_name}' not found.[/red]")
-
-        except Exception as e:
-            self.console.print(f"[red]Error removing field: {e}[/red]")
+        self.template_editor.remove_template_field(template, template_path)
 
     def _reset_template(self, agent: AgentConfig, template_path: Path) -> None:
         """Reset template to defaults."""
-        if Confirm.ask(f"[yellow]Reset '{agent.name}' template to defaults?[/yellow]"):
-            # Remove custom template file
-            template_path.unlink(missing_ok=True)
-            self.console.print(
-                f"[green]Template for '{agent.name}' reset to defaults![/green]"
-            )
+        self.template_editor.reset_template(agent, template_path)
 
     def _create_custom_template_copy(self, agent: AgentConfig, template: Dict) -> None:
         """Create a customized copy of a system template."""
-        if self.current_scope == "project":
-            config_dir = self.project_dir / ".claude-mpm" / "agents"
-        else:
-            config_dir = Path.home() / ".claude-mpm" / "agents"
+        self.template_editor.create_custom_template_copy(agent, template)
 
-        config_dir.mkdir(parents=True, exist_ok=True)
-        custom_path = config_dir / f"{agent.name}.json"
+    def _view_full_template(self, template: Dict) -> None:
+        """View the full template without truncation."""
+        self.template_editor.view_full_template(template)
 
-        if custom_path.exists() and not Confirm.ask(
-            "[yellow]Custom template already exists. Overwrite?[/yellow]"
-        ):
-            return
+    def _reset_agent_defaults(self, agents: List[AgentConfig]) -> None:
+        """Reset an agent to default enabled state and remove custom template."""
+        self.template_editor.reset_agent_defaults(agents)
 
-        # Save the template copy
-        with open(custom_path, "w") as f:
-            json.dump(template, f, indent=2)
+    def _edit_templates(self) -> None:
+        """Template editing interface."""
+        self.template_editor.edit_templates_interface()
 
-        self.console.print(f"[green]Created custom template at: {custom_path}[/green]")
-        self.console.print("[green]You can now edit this template.[/green]")
+    def _manage_behaviors(self) -> None:
+        """Behavior file management interface."""
+        # Note: BehaviorManager handles its own loop and clears screen
+        # but doesn't display our header. We'll need to update BehaviorManager
+        # to accept a header callback in the future. For now, just delegate.
+        self.behavior_manager.manage_behaviors()
 
-    def _view_full_template(self, template: Dict) -> None:
-        """View the full template without truncation."""
-        self.console.clear()
-        self.console.print("[bold]Full Template View:[/bold]\n")
+    def _manage_skills(self) -> None:
+        """Skills management interface."""
+        from ...cli.interactive.skills_wizard import SkillsWizard
+        from ...skills.skill_manager import get_manager
 
-        json_str = json.dumps(template, indent=2)
-        syntax = Syntax(json_str, "json", theme="monokai", line_numbers=True)
+        wizard = SkillsWizard()
+        manager = get_manager()
 
-        # Use pager for long content
+        while True:
+            self.console.clear()
+            self._display_header()
 
-        with self.console.pager():
-            self.console.print(syntax)
+            self.console.print("\n[bold]Skills Management Options:[/bold]\n")
+            self.console.print("  [1] View Available Skills")
+            self.console.print("  [2] Configure Skills for Agents")
+            self.console.print("  [3] View Current Skill Mappings")
+            self.console.print("  [4] Auto-Link Skills to Agents")
+            self.console.print("  [b] Back to Main Menu")
+            self.console.print()
 
-    def _view_agent_details(self, agents: List[AgentConfig]) -> None:
-        """View detailed information about an agent."""
-        agent_id = Prompt.ask("Enter agent ID to view")
+            choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
-        try:
-            idx = int(agent_id) - 1
-            if 0 <= idx < len(agents):
-                agent = agents[idx]
+            if choice == "1":
+                # View available skills
+                self.console.clear()
+                self._display_header()
+                wizard.list_available_skills()
+                Prompt.ask("\nPress Enter to continue")
 
+            elif choice == "2":
+                # Configure skills interactively
                 self.console.clear()
                 self._display_header()
 
-                # Try to load full template for more details
-                template_path = self._get_agent_template_path(agent.name)
-                extra_info = ""
+                # Get list of enabled agents
+                agents = self.agent_manager.discover_agents()
+                # Filter BASE_AGENT from all agent operations (1M-502 Phase 1)
+                agents = self._filter_agent_configs(agents, filter_deployed=False)
+                enabled_agents = [
+                    a.name
+                    for a in agents
+                    if self.agent_manager.get_pending_state(a.name)
+                ]
+
+                if not enabled_agents:
+                    self.console.print(
+                        "[yellow]No agents are currently enabled.[/yellow]"
+                    )
+                    self.console.print(
+                        "Please enable agents first in Agent Management."
+                    )
+                    Prompt.ask("\nPress Enter to continue")
+                    continue
 
-                if template_path.exists():
-                    try:
-                        with open(template_path) as f:
-                            template = json.load(f)
+                # Run skills wizard
+                success, mapping = wizard.run_interactive_selection(enabled_agents)
 
-                        # Extract additional information
-                        metadata = template.get("metadata", {})
-                        capabilities = template.get("capabilities", {})
+                if success:
+                    # Save the configuration
+                    manager.save_mappings_to_config()
+                    self.console.print("\n[green]✓ Skills configuration saved![/green]")
+                else:
+                    self.console.print(
+                        "\n[yellow]Skills configuration cancelled.[/yellow]"
+                    )
 
-                        # Get full description if available
-                        full_desc = metadata.get("description", agent.description)
+                Prompt.ask("\nPress Enter to continue")
 
-                        # Get model and tools
-                        model = capabilities.get("model", "default")
-                        tools = capabilities.get("tools", [])
+            elif choice == "3":
+                # View current mappings
+                self.console.clear()
+                self._display_header()
 
-                        # Get tags
-                        tags = metadata.get("tags", [])
+                self.console.print("\n[bold]Current Skill Mappings:[/bold]\n")
 
-                        # Get version info
-                        agent_version = template.get("agent_version", "N/A")
-                        schema_version = template.get("schema_version", "N/A")
+                mappings = manager.list_agent_skill_mappings()
+                if not mappings:
+                    self.console.print("[dim]No skill mappings configured yet.[/dim]")
+                else:
+                    from rich.table import Table
 
-                        extra_info = f"""
-[bold]Full Description:[/bold]
-{full_desc}
+                    table = Table(show_header=True, header_style="bold white")
+                    table.add_column("Agent", style="white", no_wrap=True)
+                    table.add_column("Skills", style="green", no_wrap=True)
 
-[bold]Model:[/bold] {model}
-[bold]Agent Version:[/bold] {agent_version}
-[bold]Schema Version:[/bold] {schema_version}
-[bold]Tags:[/bold] {', '.join(tags) if tags else 'None'}
-[bold]Tools:[/bold] {', '.join(tools[:5]) if tools else 'None'}{'...' if len(tools) > 5 else ''}
-"""
-                    except:
-                        pass
-
-                # Create detail panel
-                detail_text = f"""
-[bold]Name:[/bold] {agent.name}
-[bold]Status:[/bold] {'[green]Enabled[/green]' if self.agent_manager.is_agent_enabled(agent.name) else '[red]Disabled[/red]'}
-[bold]Template Path:[/bold] {template_path}
-[bold]Is System Template:[/bold] {'Yes' if str(template_path).startswith(str(self.agent_manager.templates_dir)) else 'No (Custom)'}
-{extra_info}
-                """
-
-                panel = Panel(
-                    detail_text.strip(),
-                    title=f"[bold]{agent.name} Details[/bold]",
-                    box=ROUNDED,
-                    style="cyan",
-                )
+                    for agent_id, skills in mappings.items():
+                        skills_str = (
+                            ", ".join(skills) if skills else "[dim](none)[/dim]"
+                        )
+                        table.add_row(agent_id, skills_str)
 
-                self.console.print(panel)
+                    self.console.print(table)
 
-            else:
-                self.console.print("[red]Invalid agent ID.[/red]")
+                Prompt.ask("\nPress Enter to continue")
 
-        except ValueError:
-            self.console.print("[red]Invalid input. Please enter a number.[/red]")
+            elif choice == "4":
+                # Auto-link skills
+                self.console.clear()
+                self._display_header()
 
-        Prompt.ask("\nPress Enter to continue")
+                self.console.print("\n[bold]Auto-Linking Skills to Agents...[/bold]\n")
 
-    def _edit_templates(self) -> None:
-        """Template editing interface."""
-        self.console.print("[yellow]Template editing interface - Coming soon![/yellow]")
-        Prompt.ask("Press Enter to continue")
+                # Get enabled agents
+                agents = self.agent_manager.discover_agents()
+                # Filter BASE_AGENT from all agent operations (1M-502 Phase 1)
+                agents = self._filter_agent_configs(agents, filter_deployed=False)
+                enabled_agents = [
+                    a.name
+                    for a in agents
+                    if self.agent_manager.get_pending_state(a.name)
+                ]
 
-    def _manage_behaviors(self) -> None:
-        """Behavior file management interface."""
-        while True:
-            self.console.clear()
-            self._display_header()
+                if not enabled_agents:
+                    self.console.print(
+                        "[yellow]No agents are currently enabled.[/yellow]"
+                    )
+                    self.console.print(
+                        "Please enable agents first in Agent Management."
+                    )
+                    Prompt.ask("\nPress Enter to continue")
+                    continue
 
-            self.console.print("[bold]Behavior File Management[/bold]\n")
+                # Auto-link
+                mapping = wizard._auto_link_skills(enabled_agents)
 
-            # Display current behavior files
-            self._display_behavior_files()
+                # Display preview
+                self.console.print("Auto-linked skills:\n")
+                for agent_id, skills in mapping.items():
+                    self.console.print(f"  [yellow]{agent_id}[/yellow]:")
+                    for skill in skills:
+                        self.console.print(f"    - {skill}")
 
-            # Show behavior menu
-            self.console.print("\n[bold]Options:[/bold]")
-            self.console.print("  [cyan][1][/cyan] Edit identity configuration")
-            self.console.print("  [cyan][2][/cyan] Edit workflow configuration")
-            self.console.print("  [cyan][3][/cyan] Import behavior file")
-            self.console.print("  [cyan][4][/cyan] Export behavior file")
-            self.console.print("  [cyan][b][/cyan] Back to main menu")
-            self.console.print()
+                # Confirm
+                confirm = Confirm.ask("\nApply this configuration?", default=True)
 
-            choice = Prompt.ask("[bold cyan]Select an option[/bold cyan]", default="b")
+                if confirm:
+                    wizard._apply_skills_configuration(mapping)
+                    manager.save_mappings_to_config()
+                    self.console.print("\n[green]✓ Auto-linking complete![/green]")
+                else:
+                    self.console.print("\n[yellow]Auto-linking cancelled.[/yellow]")
+
+                Prompt.ask("\nPress Enter to continue")
 
-            if choice == "b":
+            elif choice == "b":
                 break
-            if choice == "1":
-                self._edit_identity_config()
-            elif choice == "2":
-                self._edit_workflow_config()
-            elif choice == "3":
-                self._import_behavior_file()
-            elif choice == "4":
-                self._export_behavior_file()
             else:
-                self.console.print("[red]Invalid choice.[/red]")
-                Prompt.ask("Press Enter to continue")
+                self.console.print("[red]Invalid choice. Please try again.[/red]")
+                Prompt.ask("\nPress Enter to continue")
 
     def _display_behavior_files(self) -> None:
         """Display current behavior files."""
-        if self.current_scope == "project":
-            config_dir = self.project_dir / ".claude-mpm" / "behaviors"
-        else:
-            config_dir = Path.home() / ".claude-mpm" / "behaviors"
-
-        config_dir.mkdir(parents=True, exist_ok=True)
-
-        table = Table(title="Behavior Files", box=ROUNDED)
-        table.add_column("File", style="cyan", width=30)
-        table.add_column("Size", style="dim", width=10)
-        table.add_column("Modified", style="white", width=20)
-
-        identity_file = config_dir / "identity.yaml"
-        workflow_file = config_dir / "workflow.yaml"
-
-        for file_path in [identity_file, workflow_file]:
-            if file_path.exists():
-                stat = file_path.stat()
-                size = f"{stat.st_size} bytes"
-                modified = f"{stat.st_mtime:.0f}"  # Simplified timestamp
-                table.add_row(file_path.name, size, modified)
-            else:
-                table.add_row(file_path.name, "[dim]Not found[/dim]", "-")
-
-        self.console.print(table)
+        self.behavior_manager.display_behavior_files()
 
     def _edit_identity_config(self) -> None:
         """Edit identity configuration."""
-        self.console.print(
-            "[yellow]Identity configuration editor - Coming soon![/yellow]"
-        )
-        Prompt.ask("Press Enter to continue")
+        self.behavior_manager.edit_identity_config()
 
     def _edit_workflow_config(self) -> None:
         """Edit workflow configuration."""
-        self.console.print(
-            "[yellow]Workflow configuration editor - Coming soon![/yellow]"
-        )
-        Prompt.ask("Press Enter to continue")
+        self.behavior_manager.edit_workflow_config()
 
     def _import_behavior_file(self) -> None:
         """Import a behavior file."""
-        file_path = Prompt.ask("Enter path to behavior file to import")
+        self.behavior_manager.import_behavior_file()
 
-        try:
-            source = Path(file_path)
-            if not source.exists():
-                self.console.print(f"[red]File not found: {file_path}[/red]")
-                return
+    def _export_behavior_file(self) -> None:
+        """Export a behavior file."""
+        self.behavior_manager.export_behavior_file()
 
-            # Determine target directory
-            if self.current_scope == "project":
-                config_dir = self.project_dir / ".claude-mpm" / "behaviors"
-            else:
-                config_dir = Path.home() / ".claude-mpm" / "behaviors"
+    def _manage_startup_configuration(self) -> bool:
+        """Manage startup configuration for MCP services and agents."""
+        return self.startup_manager.manage_startup_configuration()
 
-            config_dir.mkdir(parents=True, exist_ok=True)
+    def _load_startup_configuration(self, config: Config) -> Dict:
+        """Load current startup configuration from config."""
+        return self.startup_manager.load_startup_configuration(config)
 
-            # Copy file
-            import shutil
+    def _display_startup_configuration(self, startup_config: Dict) -> None:
+        """Display current startup configuration in a table."""
+        self.startup_manager.display_startup_configuration(startup_config)
 
-            target = config_dir / source.name
-            shutil.copy2(source, target)
+    def _configure_mcp_services(self, startup_config: Dict, config: Config) -> None:
+        """Configure which MCP services to enable at startup."""
+        self.startup_manager.configure_mcp_services(startup_config, config)
 
-            self.console.print(f"[green]Successfully imported {source.name}![/green]")
+    def _configure_hook_services(self, startup_config: Dict, config: Config) -> None:
+        """Configure which hook services to enable at startup."""
+        self.startup_manager.configure_hook_services(startup_config, config)
 
-        except Exception as e:
-            self.console.print(f"[red]Error importing file: {e}[/red]")
+    def _configure_system_agents(self, startup_config: Dict, config: Config) -> None:
+        """Configure which system agents to deploy at startup."""
+        self.startup_manager.configure_system_agents(startup_config, config)
 
-        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')."""
+        return parse_id_selection(selection, max_id)
 
-    def _export_behavior_file(self) -> None:
-        """Export a behavior file."""
-        self.console.print("[yellow]Behavior file export - Coming soon![/yellow]")
-        Prompt.ask("Press Enter to continue")
+    def _enable_all_services(self, startup_config: Dict, config: Config) -> None:
+        """Enable all services and agents."""
+        self.startup_manager.enable_all_services(startup_config, config)
 
-    def _switch_scope(self) -> None:
-        """Switch between project and user scope."""
-        self.current_scope = "user" if self.current_scope == "project" else "project"
-        self.console.print(f"[green]Switched to {self.current_scope} scope[/green]")
-        Prompt.ask("Press Enter to continue")
+    def _disable_all_services(self, startup_config: Dict, config: Config) -> None:
+        """Disable all services and agents."""
+        self.startup_manager.disable_all_services(startup_config, config)
 
-    def _show_version_info_interactive(self) -> None:
-        """Show version information in interactive mode."""
-        self.console.clear()
-        self._display_header()
+    def _reset_to_defaults(self, startup_config: Dict, config: Config) -> None:
+        """Reset startup configuration to defaults."""
+        self.startup_manager.reset_to_defaults(startup_config, config)
 
-        # Get version information
-        mpm_version = self.version_service.get_version()
-        build_number = self.version_service.get_build_number()
+    def _save_startup_configuration(self, startup_config: Dict, config: Config) -> bool:
+        """Save startup configuration to config file and return whether to proceed to startup."""
+        return self.startup_manager.save_startup_configuration(startup_config, config)
 
-        # Try to get Claude Code version using the installer's method
-        claude_version = "Unknown"
-        try:
-            from ...hooks.claude_hooks.installer import HookInstaller
-
-            installer = HookInstaller()
-            detected_version = installer.get_claude_version()
-            if detected_version:
-                is_compatible, _ = installer.is_version_compatible()
-                claude_version = f"{detected_version} (Claude Code)"
-                if not is_compatible:
-                    claude_version += (
-                        f" - Monitoring requires {installer.MIN_CLAUDE_VERSION}+"
-                    )
-            else:
-                # Fallback to direct subprocess call
-                import subprocess
-
-                result = subprocess.run(
-                    ["claude", "--version"],
-                    capture_output=True,
-                    text=True,
-                    timeout=5,
-                    check=False,
-                )
-                if result.returncode == 0:
-                    claude_version = result.stdout.strip()
-        except:
-            pass
-
-        # Create version panel
-        version_text = f"""
-[bold cyan]Claude MPM[/bold cyan]
-Version: {mpm_version}
-Build: {build_number}
-
-[bold cyan]Claude Code[/bold cyan]
-Version: {claude_version}
-
-[bold cyan]Python[/bold cyan]
-Version: {sys.version.split()[0]}
-
-[bold cyan]Configuration[/bold cyan]
-Scope: {self.current_scope}
-Directory: {self.project_dir}
-        """
+    def _save_all_configuration(self) -> bool:
+        """Save all configuration changes across all contexts."""
+        return self.startup_manager.save_all_configuration()
 
-        panel = Panel(
-            version_text.strip(),
-            title="[bold]Version Information[/bold]",
-            box=ROUNDED,
-            style="green",
-        )
+    def _launch_claude_mpm(self) -> None:
+        """Launch Claude MPM run command, replacing current process."""
+        self.navigation.launch_claude_mpm()
 
-        self.console.print(panel)
-        Prompt.ask("\nPress Enter to continue")
+    def _switch_scope(self) -> None:
+        """Switch between project and user scope."""
+        self.navigation.switch_scope()
+        # Sync scope back from navigation
+        self.current_scope = self.navigation.current_scope
+
+    def _show_version_info_interactive(self) -> None:
+        """Show version information in interactive mode."""
+        self.persistence.show_version_info_interactive()
 
     # Non-interactive command methods
 
     def _list_agents_non_interactive(self) -> CommandResult:
         """List agents in non-interactive mode."""
         agents = self.agent_manager.discover_agents()
+        # Filter BASE_AGENT from all agent lists (1M-502 Phase 1)
+        agents = self._filter_agent_configs(agents, filter_deployed=False)
 
         data = []
         for agent in agents:
@@ -1118,291 +824,714 @@ Directory: {self.project_dir}
 
     def _export_config(self, file_path: str) -> CommandResult:
         """Export configuration to a file."""
-        try:
-            # Gather all configuration
-            config_data = {"scope": self.current_scope, "agents": {}, "behaviors": {}}
+        return self.persistence.export_config(file_path)
 
-            # Get agent states
-            agents = self.agent_manager.discover_agents()
-            for agent in agents:
-                config_data["agents"][agent.name] = {
-                    "enabled": self.agent_manager.is_agent_enabled(agent.name),
-                    "template_path": str(self._get_agent_template_path(agent.name)),
-                }
+    def _import_config(self, file_path: str) -> CommandResult:
+        """Import configuration from a file."""
+        return self.persistence.import_config(file_path)
 
-            # Write to file
-            output_path = Path(file_path)
-            with open(output_path, "w") as f:
-                json.dump(config_data, f, indent=2)
+    def _show_version_info(self) -> CommandResult:
+        """Show version information in non-interactive mode."""
+        return self.persistence.show_version_info()
 
-            return CommandResult.success_result(
-                f"Configuration exported to {output_path}"
-            )
+    def _install_hooks(self, force: bool = False) -> CommandResult:
+        """Install Claude MPM hooks for Claude Code integration."""
+        # Share logger with hook manager for consistent error logging
+        self.hook_manager.logger = self.logger
+        return self.hook_manager.install_hooks(force=force)
 
+    def _verify_hooks(self) -> CommandResult:
+        """Verify that Claude MPM hooks are properly installed."""
+        # Share logger with hook manager for consistent error logging
+        self.hook_manager.logger = self.logger
+        return self.hook_manager.verify_hooks()
+
+    def _uninstall_hooks(self) -> CommandResult:
+        """Uninstall Claude MPM hooks."""
+        # Share logger with hook manager for consistent error logging
+        self.hook_manager.logger = self.logger
+        return self.hook_manager.uninstall_hooks()
+
+    def _run_agent_management(self) -> CommandResult:
+        """Jump directly to agent management."""
+        try:
+            self._manage_agents()
+            return CommandResult.success_result("Agent management completed")
+        except KeyboardInterrupt:
+            return CommandResult.success_result("Agent management cancelled")
         except Exception as e:
-            return CommandResult.error_result(f"Failed to export configuration: {e}")
+            return CommandResult.error_result(f"Agent management failed: {e}")
 
-    def _import_config(self, file_path: str) -> CommandResult:
-        """Import configuration from a file."""
+    def _run_template_editing(self) -> CommandResult:
+        """Jump directly to template editing."""
         try:
-            input_path = Path(file_path)
-            if not input_path.exists():
-                return CommandResult.error_result(f"File not found: {file_path}")
-
-            with open(input_path) as f:
-                config_data = json.load(f)
-
-            # Apply agent states
-            if "agents" in config_data:
-                for agent_name, agent_config in config_data["agents"].items():
-                    if "enabled" in agent_config:
-                        self.agent_manager.set_agent_enabled(
-                            agent_name, agent_config["enabled"]
-                        )
+            self._edit_templates()
+            return CommandResult.success_result("Template editing completed")
+        except KeyboardInterrupt:
+            return CommandResult.success_result("Template editing cancelled")
+        except Exception as e:
+            return CommandResult.error_result(f"Template editing failed: {e}")
 
-            return CommandResult.success_result(
-                f"Configuration imported from {input_path}"
-            )
+    def _run_behavior_management(self) -> CommandResult:
+        """Jump directly to behavior management."""
+        return self.behavior_manager.run_behavior_management()
 
+    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"Failed to import configuration: {e}")
+            return CommandResult.error_result(f"Startup configuration failed: {e}")
 
-    def _show_version_info(self) -> CommandResult:
-        """Show version information in non-interactive mode."""
-        mpm_version = self.version_service.get_version()
-        build_number = self.version_service.get_build_number()
-
-        data = {
-            "mpm_version": mpm_version,
-            "build_number": build_number,
-            "python_version": sys.version.split()[0],
-        }
+    # ========================================================================
+    # Enhanced Agent Management Methods (Remote Agent Discovery Integration)
+    # ========================================================================
 
-        # Try to get Claude version
+    def _get_configured_sources(self) -> List[Dict]:
+        """Get list of configured agent sources with agent counts."""
         try:
-            import subprocess
-
-            result = subprocess.run(
-                ["claude", "--version"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-                check=False,
+            from claude_mpm.config.agent_sources import AgentSourceConfiguration
+
+            config = AgentSourceConfiguration.load()
+
+            # Convert repositories to source dictionaries
+            sources = []
+            for repo in config.repositories:
+                # Extract identifier from repository
+                identifier = repo.identifier
+
+                # Count agents in cache
+                cache_dir = (
+                    Path.home() / ".claude-mpm" / "cache" / "remote-agents" / identifier
+                )
+                agent_count = 0
+                if cache_dir.exists():
+                    agents_dir = cache_dir / "agents"
+                    if agents_dir.exists():
+                        agent_count = len(list(agents_dir.rglob("*.md")))
+
+                sources.append(
+                    {
+                        "identifier": identifier,
+                        "url": repo.url,
+                        "enabled": repo.enabled,
+                        "priority": repo.priority,
+                        "agent_count": agent_count,
+                    }
+                )
+
+            return sources
+        except Exception as e:
+            self.logger.warning(f"Failed to get configured sources: {e}")
+            return []
+
+    def _filter_agent_configs(
+        self, agents: List[AgentConfig], filter_deployed: bool = False
+    ) -> List[AgentConfig]:
+        """Filter AgentConfig objects using agent_filters utilities.
+
+        Converts AgentConfig objects to dictionaries for filtering,
+        then back to AgentConfig. Always filters BASE_AGENT.
+        Optionally filters deployed agents.
+
+        Args:
+            agents: List of AgentConfig objects
+            filter_deployed: Whether to filter out deployed agents (default: False)
+
+        Returns:
+            Filtered list of AgentConfig objects
+        """
+        # Convert AgentConfig to dict format for filtering
+        agent_dicts = []
+        for agent in agents:
+            agent_dicts.append(
+                {
+                    "agent_id": agent.name,
+                    "name": agent.name,
+                    "description": agent.description,
+                    "deployed": getattr(agent, "is_deployed", False),
+                }
             )
-            if result.returncode == 0:
-                data["claude_version"] = result.stdout.strip()
-        except:
-            data["claude_version"] = "Unknown"
 
-        # Print formatted output
-        self.console.print(
-            f"[bold]Claude MPM:[/bold] {mpm_version} (build {build_number})"
+        # Apply filters (always filter BASE_AGENT)
+        filtered_dicts = apply_all_filters(
+            agent_dicts, filter_base=True, filter_deployed=filter_deployed
         )
+
+        # Convert back to AgentConfig objects
+        filtered_names = {d["agent_id"] for d in filtered_dicts}
+        return [a for a in agents if a.name in filtered_names]
+
+    def _display_agents_with_source_info(self, agents: List[AgentConfig]) -> None:
+        """Display agents table with source information and installation status."""
+        from rich.table import Table
+
+        agents_table = Table(show_header=True, header_style="bold white")
+        agents_table.add_column("#", style="dim", width=4, no_wrap=True)
+        agents_table.add_column(
+            "Agent ID", style="white", width=35, no_wrap=True, overflow="ellipsis"
+        )
+        agents_table.add_column(
+            "Name", style="white", width=25, no_wrap=True, overflow="ellipsis"
+        )
+        agents_table.add_column("Source", style="bright_yellow", width=20, no_wrap=True)
+        agents_table.add_column("Status", style="white", width=12, no_wrap=True)
+
+        for idx, agent in enumerate(agents, 1):
+            # Determine source with repo name
+            source_type = getattr(agent, "source_type", "local")
+
+            if source_type == "remote":
+                # Get repo name from agent metadata
+                source_dict = getattr(agent, "source_dict", {})
+                repo_url = source_dict.get("source", "")
+
+                # Extract repo name from URL
+                if (
+                    "bobmatnyc/claude-mpm" in repo_url
+                    or "claude-mpm" in repo_url.lower()
+                ):
+                    source_label = "MPM Agents"
+                elif "/" in repo_url:
+                    # Extract last part of org/repo
+                    parts = repo_url.rstrip("/").split("/")
+                    if len(parts) >= 2:
+                        source_label = f"{parts[-2]}/{parts[-1]}"
+                    else:
+                        source_label = "Community"
+                else:
+                    source_label = "Community"
+            else:
+                source_label = "Local"
+
+            # Determine installation status (removed symbols for cleaner look)
+            is_installed = getattr(agent, "is_deployed", False)
+            if is_installed:
+                status = "[green]Installed[/green]"
+            else:
+                status = "Available"
+
+            # Get display name (for remote agents, use display_name instead of agent_id)
+            display_name = getattr(agent, "display_name", agent.name)
+            # Let overflow="ellipsis" handle truncation automatically
+
+            agents_table.add_row(
+                str(idx), agent.name, display_name, source_label, status
+            )
+
+        self.console.print(agents_table)
+        self.console.print(f"\n[dim]Total: {len(agents)} agents available[/dim]")
+
+    def _manage_sources(self) -> None:
+        """Interactive source management."""
+        self.console.print("\n[bold white]═══ Manage Agent Sources ═══[/bold white]\n")
         self.console.print(
-            f"[bold]Claude Code:[/bold] {data.get('claude_version', 'Unknown')}"
+            "[dim]Use 'claude-mpm agent-source' command to add/remove sources[/dim]"
         )
-        self.console.print(f"[bold]Python:[/bold] {data['python_version']}")
+        self.console.print("\nExamples:")
+        self.console.print("  claude-mpm agent-source add <git-url>")
+        self.console.print("  claude-mpm agent-source remove <identifier>")
+        self.console.print("  claude-mpm agent-source list")
+        Prompt.ask("\nPress Enter to continue")
 
-        return CommandResult.success_result("Version information displayed", data=data)
+    def _deploy_agents_individual(self, agents: List[AgentConfig]) -> None:
+        """Manage agent installation state (unified install/remove interface)."""
+        if not agents:
+            self.console.print("[yellow]No agents available[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
 
-    def _install_hooks(self, force: bool = False) -> CommandResult:
-        """Install Claude MPM hooks for Claude Code integration."""
-        try:
-            from ...hooks.claude_hooks.installer import HookInstaller
+        # Get ALL agents (filter BASE_AGENT but keep deployed agents visible)
+        from claude_mpm.utils.agent_filters import (
+            filter_base_agents,
+            get_deployed_agent_ids,
+        )
+
+        # Filter BASE_AGENT but keep deployed agents visible
+        all_agents = filter_base_agents(
+            [
+                {
+                    "agent_id": a.name,
+                    "name": a.name,
+                    "description": a.description,
+                    "deployed": getattr(a, "is_deployed", False),
+                }
+                for a in agents
+            ]
+        )
+
+        # Get deployed agent IDs
+        deployed_ids = get_deployed_agent_ids()
+
+        if not all_agents:
+            self.console.print("[yellow]No agents available[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Loop to allow adjusting selection
+        while True:
+            # Build checkbox choices with pre-selection
+            agent_choices = []
+            agent_map = {}  # For lookup after selection
+
+            for agent in agents:
+                if agent.name in {a["agent_id"] for a in all_agents}:
+                    display_name = getattr(agent, "display_name", agent.name)
+
+                    # Pre-check if deployed
+                    # Extract leaf name from full path for comparison with deployed_ids
+                    agent_leaf_name = agent.name.split("/")[-1]
+                    is_deployed = agent_leaf_name in deployed_ids
+
+                    # Simple format: "agent/path - Display Name"
+                    # Checkbox state (checked/unchecked) indicates installed status
+                    choice_text = f"{agent.name}"
+                    if display_name and display_name != agent.name:
+                        choice_text += f" - {display_name}"
+
+                    # Create choice with checked=True for deployed agents
+                    # Note: questionary's default param is for single-select only
+                    # For multi-select, must use checked=True on Choice objects
+                    choice = questionary.Choice(
+                        title=choice_text, value=agent.name, checked=is_deployed
+                    )
+
+                    agent_choices.append(choice)
+                    agent_map[agent.name] = agent
+
+            # Multi-select with pre-selection
+            self.console.print("\n[bold cyan]Manage Agent Installation[/bold cyan]")
+            self.console.print("[dim]✓ Checked = Installed (uncheck to remove)[/dim]")
+            self.console.print("[dim]○ Unchecked = Available (check to install)[/dim]")
+            self.console.print(
+                "[dim]Use arrow keys to navigate, space to toggle, "
+                "Enter to apply changes[/dim]\n"
+            )
+
+            # Pre-selection via checked=True on Choice objects
+            # (questionary's default param is for single-select only)
+            selected_agent_ids = questionary.checkbox(
+                "Agents:", choices=agent_choices, style=self.QUESTIONARY_STYLE
+            ).ask()
+
+            # Handle Esc
+            if selected_agent_ids is None:
+                self.console.print("[yellow]No changes made[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            # Convert to sets for comparison
+            selected_set = set(selected_agent_ids)
+            deployed_set = deployed_ids
+
+            # Determine actions
+            to_deploy = selected_set - deployed_set  # Selected but not deployed
+            to_remove = deployed_set - selected_set  # Deployed but not selected
+
+            if not to_deploy and not to_remove:
+                self.console.print("[yellow]No changes made[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            # Show what will happen
+            self.console.print("\n[bold]Changes to apply:[/bold]")
+            if to_deploy:
+                self.console.print(f"[green]Install {len(to_deploy)} agent(s)[/green]")
+                for agent_id in to_deploy:
+                    self.console.print(f"  + {agent_id}")
+            if to_remove:
+                self.console.print(f"[red]Remove {len(to_remove)} agent(s)[/red]")
+                for agent_id in to_remove:
+                    self.console.print(f"  - {agent_id}")
+
+            # Ask user to confirm, adjust, or cancel
+            action = questionary.select(
+                "\nWhat would you like to do?",
+                choices=[
+                    questionary.Choice("Apply these changes", value="apply"),
+                    questionary.Choice("Adjust selection", value="adjust"),
+                    questionary.Choice("Cancel", value="cancel"),
+                ],
+                default="apply",
+                style=self.QUESTIONARY_STYLE,
+            ).ask()
+
+            if action == "cancel":
+                self.console.print("[yellow]Changes cancelled[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
+            if action == "adjust":
+                # Loop back to agent selection
+                continue
+
+            # Execute changes
+            deploy_success = 0
+            deploy_fail = 0
+            remove_success = 0
+            remove_fail = 0
+
+            # Install new agents
+            for agent_id in to_deploy:
+                agent = agent_map.get(agent_id)
+                if agent and self._deploy_single_agent(agent, show_feedback=False):
+                    deploy_success += 1
+                    self.console.print(f"[green]✓ Installed: {agent_id}[/green]")
+                else:
+                    deploy_fail += 1
+                    self.console.print(f"[red]✗ Failed to install: {agent_id}[/red]")
 
-            installer = HookInstaller()
+            # Remove agents
+            for agent_id in to_remove:
+                try:
+                    import json
+                    from pathlib import Path
 
-            # Check Claude Code version compatibility first
-            is_compatible, version_message = installer.is_version_compatible()
-            self.console.print("[cyan]Checking Claude Code version...[/cyan]")
-            self.console.print(version_message)
+                    # Remove from project, legacy, and user locations
+                    project_path = (
+                        Path.cwd() / ".claude-mpm" / "agents" / f"{agent_id}.md"
+                    )
+                    legacy_path = Path.cwd() / ".claude" / "agents" / f"{agent_id}.md"
+                    user_path = Path.home() / ".claude" / "agents" / f"{agent_id}.md"
+
+                    removed = False
+                    for path in [project_path, legacy_path, user_path]:
+                        if path.exists():
+                            path.unlink()
+                            removed = True
+
+                    # Also remove from virtual deployment state
+                    deployment_state_paths = [
+                        Path.cwd() / ".claude" / "agents" / ".mpm_deployment_state",
+                        Path.home() / ".claude" / "agents" / ".mpm_deployment_state",
+                    ]
+
+                    for state_path in deployment_state_paths:
+                        if state_path.exists():
+                            try:
+                                with state_path.open() as f:
+                                    state = json.load(f)
+
+                                # Remove agent from deployment state
+                                agents = state.get("last_check_results", {}).get(
+                                    "agents", {}
+                                )
+                                if agent_id in agents:
+                                    del agents[agent_id]
+                                    removed = True
+
+                                    # Save updated state
+                                    with state_path.open("w") as f:
+                                        json.dump(state, f, indent=2)
+                            except (json.JSONDecodeError, KeyError) as e:
+                                # Log but don't fail - physical removal still counts
+                                self.logger.debug(
+                                    f"Failed to update deployment state at {state_path}: {e}"
+                                )
+
+                    if removed:
+                        remove_success += 1
+                        self.console.print(f"[green]✓ Removed: {agent_id}[/green]")
+                    else:
+                        remove_fail += 1
+                        self.console.print(f"[yellow]⚠ Not found: {agent_id}[/yellow]")
+                except Exception as e:
+                    remove_fail += 1
+                    self.console.print(f"[red]✗ Failed to remove {agent_id}: {e}[/red]")
 
-            if not is_compatible:
+            # Show summary
+            self.console.print()
+            if deploy_success > 0:
                 self.console.print(
-                    "\n[yellow]⚠ Hook monitoring is not available for your Claude Code version.[/yellow]"
+                    f"[green]✓ Installed {deploy_success} agent(s)[/green]"
                 )
+            if deploy_fail > 0:
                 self.console.print(
-                    "The dashboard and other features will work without real-time monitoring."
+                    f"[red]✗ Failed to install {deploy_fail} agent(s)[/red]"
                 )
+            if remove_success > 0:
                 self.console.print(
-                    f"\n[dim]To enable monitoring, upgrade Claude Code to version {installer.MIN_CLAUDE_VERSION} or higher.[/dim]"
+                    f"[green]✓ Removed {remove_success} agent(s)[/green]"
                 )
-                return CommandResult.success_result(
-                    "Version incompatible with hook monitoring",
-                    data={"compatible": False, "message": version_message},
+            if remove_fail > 0:
+                self.console.print(
+                    f"[red]✗ Failed to remove {remove_fail} agent(s)[/red]"
                 )
 
-            # Check current status
-            status = installer.get_status()
-            if status["installed"] and not force:
-                self.console.print("[yellow]Hooks are already installed.[/yellow]")
-                self.console.print("Use --force to reinstall.")
+            Prompt.ask("\nPress Enter to continue")
+            # Exit the loop after successful execution
+            break
 
-                if not status["valid"]:
-                    self.console.print("\n[red]However, there are issues:[/red]")
-                    for issue in status["issues"]:
-                        self.console.print(f"  - {issue}")
+    def _deploy_agents_preset(self) -> None:
+        """Install agents using preset configuration."""
+        try:
+            from claude_mpm.services.agents.agent_preset_service import (
+                AgentPresetService,
+            )
+            from claude_mpm.services.agents.git_source_manager import GitSourceManager
 
-                return CommandResult.success_result(
-                    "Hooks already installed", data=status
-                )
+            source_manager = GitSourceManager()
+            preset_service = AgentPresetService(source_manager)
 
-            # Install hooks
-            self.console.print("[cyan]Installing Claude MPM hooks...[/cyan]")
-            success = installer.install_hooks(force=force)
+            presets = preset_service.list_presets()
 
-            if success:
-                self.console.print("[green]✓ Hooks installed successfully![/green]")
-                self.console.print("\nYou can now use /mpm commands in Claude Code:")
-                self.console.print("  /mpm         - Show help")
-                self.console.print("  /mpm status  - Show claude-mpm status")
+            if not presets:
+                self.console.print("[yellow]No presets available[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
 
-                # Verify installation
-                is_valid, issues = installer.verify_hooks()
-                if not is_valid:
-                    self.console.print(
-                        "\n[yellow]Warning: Installation completed but verification found issues:[/yellow]"
-                    )
-                    for issue in issues:
-                        self.console.print(f"  - {issue}")
+            self.console.print("\n[bold white]═══ Available Presets ═══[/bold white]\n")
+            for idx, preset in enumerate(presets, 1):
+                self.console.print(f"  {idx}. [white]{preset['name']}[/white]")
+                self.console.print(f"     {preset['description']}")
+                self.console.print(f"     [dim]Agents: {len(preset['agents'])}[/dim]\n")
 
-                return CommandResult.success_result("Hooks installed successfully")
-            self.console.print("[red]✗ Hook installation failed[/red]")
-            return CommandResult.error_result("Hook installation failed")
+            selection = Prompt.ask("\nEnter preset number (or 'c' to cancel)")
+            if selection.lower() == "c":
+                return
 
-        except ImportError:
-            self.console.print("[red]Error: HookInstaller module not found[/red]")
-            self.console.print("Please ensure claude-mpm is properly installed.")
-            return CommandResult.error_result("HookInstaller module not found")
-        except Exception as e:
-            self.logger.error(f"Hook installation error: {e}", exc_info=True)
-            return CommandResult.error_result(f"Hook installation failed: {e}")
+            idx = int(selection) - 1
+            if 0 <= idx < len(presets):
+                preset_name = presets[idx]["name"]
 
-    def _verify_hooks(self) -> CommandResult:
-        """Verify that Claude MPM hooks are properly installed."""
-        try:
-            from ...hooks.claude_hooks.installer import HookInstaller
+                # Resolve and deploy preset
+                resolution = preset_service.resolve_agents(preset_name)
 
-            installer = HookInstaller()
-            status = installer.get_status()
+                if resolution.get("missing_agents"):
+                    self.console.print(
+                        f"[red]Missing agents: {len(resolution['missing_agents'])}[/red]"
+                    )
+                    for agent_id in resolution["missing_agents"]:
+                        self.console.print(f"  • {agent_id}")
+                    Prompt.ask("\nPress Enter to continue")
+                    return
 
-            self.console.print("[bold]Hook Installation Status[/bold]\n")
+                # Confirm installation
+                self.console.print(
+                    f"\n[bold]Preset '{preset_name}' includes {len(resolution['agents'])} agents[/bold]"
+                )
+                if Confirm.ask("Install all agents?", default=True):
+                    installed = 0
+                    for agent in resolution["agents"]:
+                        # Convert dict to AgentConfig-like object for installation
+                        agent_config = AgentConfig(
+                            name=agent.get("agent_id", "unknown"),
+                            description=agent.get("metadata", {}).get(
+                                "description", ""
+                            ),
+                            dependencies=[],
+                        )
+                        agent_config.source_dict = agent
+                        agent_config.full_agent_id = agent.get("agent_id", "unknown")
+
+                        if self._deploy_single_agent(agent_config, show_feedback=False):
+                            installed += 1
 
-            # Show Claude Code version and compatibility
-            if status.get("claude_version"):
-                self.console.print(f"Claude Code Version: {status['claude_version']}")
-                if status.get("version_compatible"):
                     self.console.print(
-                        "[green]✓[/green] Version compatible with hook monitoring"
+                        f"\n[green]✓ Installed {installed}/{len(resolution['agents'])} agents[/green]"
                     )
+
+                Prompt.ask("\nPress Enter to continue")
+            else:
+                self.console.print("[red]Invalid selection[/red]")
+                Prompt.ask("\nPress Enter to continue")
+
+        except Exception as e:
+            self.console.print(f"[red]Error installing preset: {e}[/red]")
+            self.logger.error(f"Preset installation failed: {e}", exc_info=True)
+            Prompt.ask("\nPress Enter to continue")
+
+    def _deploy_single_agent(
+        self, agent: AgentConfig, show_feedback: bool = True
+    ) -> bool:
+        """Install a single agent to the appropriate location."""
+        try:
+            # Check if this is a remote agent with source_dict
+            source_dict = getattr(agent, "source_dict", None)
+            full_agent_id = getattr(agent, "full_agent_id", agent.name)
+
+            if source_dict:
+                # Deploy remote agent using its source file
+                source_file = Path(source_dict.get("source_file", ""))
+                if not source_file.exists():
+                    if show_feedback:
+                        self.console.print(
+                            f"[red]✗ Source file not found: {source_file}[/red]"
+                        )
+                    return False
+
+                # Determine target file name (use leaf name from hierarchical ID)
+                if "/" in full_agent_id:
+                    target_name = full_agent_id.split("/")[-1] + ".md"
                 else:
+                    target_name = full_agent_id + ".md"
+
+                # Deploy to user-level agents directory
+                target_dir = Path.home() / ".claude" / "agents"
+                target_dir.mkdir(parents=True, exist_ok=True)
+                target_file = target_dir / target_name
+
+                if show_feedback:
                     self.console.print(
-                        f"[yellow]⚠[/yellow] {status.get('version_message', 'Version incompatible')}"
+                        f"\n[white]Installing {full_agent_id}...[/white]"
                     )
-                    self.console.print()
-            else:
-                self.console.print(
-                    "[yellow]Claude Code version could not be detected[/yellow]"
-                )
-            self.console.print()
 
-            if status["installed"]:
-                self.console.print(
-                    f"[green]✓[/green] Hooks installed at: {status['hook_script']}"
-                )
-            else:
-                self.console.print("[red]✗[/red] Hooks not installed")
+                # Copy the agent file
+                import shutil
 
-            if status["settings_file"]:
-                self.console.print(
-                    f"[green]✓[/green] Settings file: {status['settings_file']}"
-                )
-            else:
-                self.console.print("[red]✗[/red] Settings file not found")
+                shutil.copy2(source_file, target_file)
 
-            if status.get("configured_events"):
+                if show_feedback:
+                    self.console.print(
+                        f"[green]✓ Successfully installed {full_agent_id} to {target_file}[/green]"
+                    )
+                    Prompt.ask("\nPress Enter to continue")
+
+                return True
+            # Legacy local template installation (not implemented here)
+            if show_feedback:
                 self.console.print(
-                    f"[green]✓[/green] Configured events: {', '.join(status['configured_events'])}"
+                    "[yellow]Local template installation not yet implemented[/yellow]"
                 )
-            else:
-                self.console.print("[red]✗[/red] No events configured")
-
-            if status["valid"]:
-                self.console.print("\n[green]All checks passed![/green]")
-            else:
-                self.console.print("\n[red]Issues found:[/red]")
-                for issue in status["issues"]:
-                    self.console.print(f"  - {issue}")
+                Prompt.ask("\nPress Enter to continue")
+            return False
 
-            return CommandResult.success_result(
-                "Hook verification complete", data=status
-            )
-
-        except ImportError:
-            self.console.print("[red]Error: HookInstaller module not found[/red]")
-            return CommandResult.error_result("HookInstaller module not found")
         except Exception as e:
-            self.logger.error(f"Hook verification error: {e}", exc_info=True)
-            return CommandResult.error_result(f"Hook verification failed: {e}")
+            if show_feedback:
+                self.console.print(f"[red]Error installing agent: {e}[/red]")
+                self.logger.error(f"Agent installation failed: {e}", exc_info=True)
+                Prompt.ask("\nPress Enter to continue")
+            return False
+
+    def _remove_agents(self, agents: List[AgentConfig]) -> None:
+        """Remove installed agents."""
+        # Filter to installed agents only
+        installed = [a for a in agents if getattr(a, "is_deployed", False)]
+
+        if not installed:
+            self.console.print("[yellow]No agents are currently installed[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
 
-    def _uninstall_hooks(self) -> CommandResult:
-        """Uninstall Claude MPM hooks."""
-        try:
-            from ...hooks.claude_hooks.installer import HookInstaller
+        self.console.print(f"\n[bold]Installed agents ({len(installed)}):[/bold]")
+        for idx, agent in enumerate(installed, 1):
+            display_name = getattr(agent, "display_name", agent.name)
+            self.console.print(f"  {idx}. {agent.name} - {display_name}")
 
-            installer = HookInstaller()
+        selection = Prompt.ask("\nEnter agent number to remove (or 'c' to cancel)")
+        if selection.lower() == "c":
+            return
 
-            # Confirm uninstallation
-            if not Confirm.ask(
-                "[yellow]Are you sure you want to uninstall Claude MPM hooks?[/yellow]"
-            ):
-                return CommandResult.success_result("Uninstallation cancelled")
+        try:
+            idx = int(selection) - 1
+            if 0 <= idx < len(installed):
+                agent = installed[idx]
+                full_agent_id = getattr(agent, "full_agent_id", agent.name)
+
+                # Determine possible file names (hierarchical and leaf)
+                file_names = [f"{full_agent_id}.md"]
+                if "/" in full_agent_id:
+                    leaf_name = full_agent_id.split("/")[-1]
+                    file_names.append(f"{leaf_name}.md")
+
+                # Remove from both project and user directories
+                removed = False
+                project_agent_dir = Path.cwd() / ".claude-mpm" / "agents"
+                user_agent_dir = Path.home() / ".claude" / "agents"
+
+                for file_name in file_names:
+                    project_file = project_agent_dir / file_name
+                    user_file = user_agent_dir / file_name
+
+                    if project_file.exists():
+                        project_file.unlink()
+                        removed = True
+                        self.console.print(f"[green]✓ Removed {project_file}[/green]")
+
+                    if user_file.exists():
+                        user_file.unlink()
+                        removed = True
+                        self.console.print(f"[green]✓ Removed {user_file}[/green]")
+
+                if removed:
+                    self.console.print(
+                        f"[green]✓ Successfully removed {full_agent_id}[/green]"
+                    )
+                else:
+                    self.console.print("[yellow]Agent files not found[/yellow]")
 
-            self.console.print("[cyan]Uninstalling Claude MPM hooks...[/cyan]")
-            success = installer.uninstall_hooks()
+                Prompt.ask("\nPress Enter to continue")
+            else:
+                self.console.print("[red]Invalid selection[/red]")
+                Prompt.ask("\nPress Enter to continue")
+
+        except (ValueError, IndexError):
+            self.console.print("[red]Invalid selection[/red]")
+            Prompt.ask("\nPress Enter to continue")
+
+    def _view_agent_details_enhanced(self, agents: List[AgentConfig]) -> None:
+        """View detailed agent information with enhanced remote agent details."""
+        if not agents:
+            self.console.print("[yellow]No agents available[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
 
-            if success:
-                self.console.print("[green]✓ Hooks uninstalled successfully![/green]")
-                return CommandResult.success_result("Hooks uninstalled successfully")
-            self.console.print("[red]✗ Hook uninstallation failed[/red]")
-            return CommandResult.error_result("Hook uninstallation failed")
+        self.console.print(f"\n[bold]Available agents ({len(agents)}):[/bold]")
+        for idx, agent in enumerate(agents, 1):
+            display_name = getattr(agent, "display_name", agent.name)
+            self.console.print(f"  {idx}. {agent.name} - {display_name}")
 
-        except ImportError:
-            self.console.print("[red]Error: HookInstaller module not found[/red]")
-            return CommandResult.error_result("HookInstaller module not found")
-        except Exception as e:
-            self.logger.error(f"Hook uninstallation error: {e}", exc_info=True)
-            return CommandResult.error_result(f"Hook uninstallation failed: {e}")
+        selection = Prompt.ask("\nEnter agent number to view (or 'c' to cancel)")
+        if selection.lower() == "c":
+            return
 
-    def _run_agent_management(self) -> CommandResult:
-        """Jump directly to agent management."""
         try:
-            self._manage_agents()
-            return CommandResult.success_result("Agent management completed")
-        except KeyboardInterrupt:
-            return CommandResult.success_result("Agent management cancelled")
-        except Exception as e:
-            return CommandResult.error_result(f"Agent management failed: {e}")
+            idx = int(selection) - 1
+            if 0 <= idx < len(agents):
+                agent = agents[idx]
 
-    def _run_template_editing(self) -> CommandResult:
-        """Jump directly to template editing."""
-        try:
-            self._edit_templates()
-            return CommandResult.success_result("Template editing completed")
-        except KeyboardInterrupt:
-            return CommandResult.success_result("Template editing cancelled")
-        except Exception as e:
-            return CommandResult.error_result(f"Template editing failed: {e}")
+                self.console.clear()
+                self.console.print("\n[bold white]═══ Agent Details ═══[/bold white]\n")
+
+                # Basic info
+                self.console.print(f"[bold]ID:[/bold] {agent.name}")
+                display_name = getattr(agent, "display_name", "N/A")
+                self.console.print(f"[bold]Name:[/bold] {display_name}")
+                self.console.print(f"[bold]Description:[/bold] {agent.description}")
+
+                # Source info
+                source_type = getattr(agent, "source_type", "local")
+                self.console.print(f"[bold]Source Type:[/bold] {source_type}")
+
+                if source_type == "remote":
+                    source_dict = getattr(agent, "source_dict", {})
+                    category = source_dict.get("category", "N/A")
+                    source = source_dict.get("source", "N/A")
+                    version = source_dict.get("version", "N/A")
+
+                    self.console.print(f"[bold]Category:[/bold] {category}")
+                    self.console.print(f"[bold]Source:[/bold] {source}")
+                    self.console.print(f"[bold]Version:[/bold] {version[:16]}...")
+
+                # Installation status
+                is_installed = getattr(agent, "is_deployed", False)
+                status = "Installed" if is_installed else "Available"
+                self.console.print(f"[bold]Status:[/bold] {status}")
+
+                Prompt.ask("\nPress Enter to continue")
+            else:
+                self.console.print("[red]Invalid selection[/red]")
+                Prompt.ask("\nPress Enter to continue")
 
-    def _run_behavior_management(self) -> CommandResult:
-        """Jump directly to behavior management."""
-        try:
-            self._manage_behaviors()
-            return CommandResult.success_result("Behavior management completed")
-        except KeyboardInterrupt:
-            return CommandResult.success_result("Behavior management cancelled")
-        except Exception as e:
-            return CommandResult.error_result(f"Behavior management failed: {e}")
+        except (ValueError, IndexError):
+            self.console.print("[red]Invalid selection[/red]")
+            Prompt.ask("\nPress Enter to continue")
 
 
 def manage_configure(args) -> int: