claude-mpm 4.21.3__py3-none-any.whl → 5.1.9__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -12,15 +12,21 @@ DESIGN DECISIONS:
 """
 
 import json
+import shutil
 from pathlib import Path
 from typing import Dict, List, Optional
 
+import questionary
+import questionary.constants
+import questionary.prompts.common  # For checkbox symbol customization
+from questionary import Style
 from rich.console import Console
 from rich.prompt import Confirm, Prompt
 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
 from .agent_state_manager import SimpleAgentManager
@@ -41,6 +47,21 @@ from .configure_validators import (
 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
@@ -284,61 +305,140 @@ class ConfigureCommand(BaseCommand):
         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()
+            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
+                )
 
-            # Display available agents
-            agents = self.agent_manager.discover_agents()
-            self._display_agents_table(agents)
+                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)
+                    )
 
-            # Show agent menu
-            self.console.print("\n[bold]Agent Management Options:[/bold]")
+                self.console.print(sources_table)
+            else:
+                self.console.print("[yellow]No agent sources configured[/yellow]")
+                self.console.print(
+                    "[dim]Default source 'bobmatnyc/claude-mpm-agents' will be used[/dim]\n"
+                )
 
-            # Use Text objects to properly display shortcuts with styling
-            text_t = Text("  ")
-            text_t.append("[t]", style="bold blue")
-            text_t.append(" Toggle agents (enable/disable multiple)")
-            self.console.print(text_t)
+            # Step 2: Discover and display available agents
+            self.console.print("\n[bold white]═══ Available Agents ═══[/bold white]\n")
 
-            text_c = Text("  ")
-            text_c.append("[c]", style="bold blue")
-            text_c.append(" Customize agent template")
-            self.console.print(text_c)
+            try:
+                # Discover agents (includes both local and remote)
+                agents = self.agent_manager.discover_agents(include_remote=True)
 
-            text_v = Text("  ")
-            text_v.append("[v]", style="bold blue")
-            text_v.append(" View agent details")
-            self.console.print(text_v)
+                # 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
 
-            text_r = Text("  ")
-            text_r.append("[r]", style="bold blue")
-            text_r.append(" Reset agent to defaults")
-            self.console.print(text_r)
+                # Filter BASE_AGENT from display (1M-502 Phase 1)
+                agents = self._filter_agent_configs(agents, filter_deployed=False)
 
-            text_b = Text("  ")
-            text_b.append("[b]", style="bold blue")
-            text_b.append(" Back to main menu")
-            self.console.print(text_b)
+                if not agents:
+                    self.console.print("[yellow]No agents found[/yellow]")
+                    self.console.print(
+                        "[dim]Configure sources with 'claude-mpm agent-source add'[/dim]\n"
+                    )
+                else:
+                    # Display agents in a table (already filtered at line 339)
+                    self._display_agents_with_source_info(agents)
 
-            self.console.print()
+            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)
 
-            choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
+            # Step 3: Menu options with arrow-key navigation
+            self.console.print()
+            self.logger.debug("About to show agent management menu")
+            try:
+                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
 
-            if choice == "b":
+                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.logger.debug("User selected 'Select Agents' from menu")
+                    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
+            except Exception as e:
+                # Handle questionary menu failure
+                import sys
+
+                self.logger.error(f"Agent management menu failed: {e}", exc_info=True)
+                self.console.print("[red]Error: Interactive menu failed[/red]")
+                self.console.print(f"[dim]Reason: {e}[/dim]")
+                if not sys.stdin.isatty():
+                    self.console.print(
+                        "[dim]Interactive terminal required for this operation[/dim]"
+                    )
+                    self.console.print("[dim]Use command-line options instead:[/dim]")
+                    self.console.print(
+                        "[dim]  claude-mpm configure --list-agents[/dim]"
+                    )
+                    self.console.print(
+                        "[dim]  claude-mpm configure --enable-agent <id>[/dim]"
+                    )
+                Prompt.ask("\nPress Enter to continue")
                 break
-            if choice == "t":
-                self._toggle_agents_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)
-            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."""
@@ -511,6 +611,8 @@ class ConfigureCommand(BaseCommand):
 
                 # 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
@@ -554,9 +656,9 @@ class ConfigureCommand(BaseCommand):
                 else:
                     from rich.table import Table
 
-                    table = Table(show_header=True, header_style="bold cyan")
-                    table.add_column("Agent", style="yellow")
-                    table.add_column("Skills", style="green")
+                    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)
 
                     for agent_id, skills in mappings.items():
                         skills_str = (
@@ -577,6 +679,8 @@ class ConfigureCommand(BaseCommand):
 
                 # 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
@@ -708,6 +812,8 @@ class ConfigureCommand(BaseCommand):
     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:
@@ -809,6 +915,790 @@ class ConfigureCommand(BaseCommand):
         except Exception as e:
             return CommandResult.error_result(f"Startup configuration failed: {e}")
 
+    # ========================================================================
+    # Enhanced Agent Management Methods (Remote Agent Discovery Integration)
+    # ========================================================================
+
+    def _get_configured_sources(self) -> List[Dict]:
+        """Get list of configured agent sources with agent counts."""
+        try:
+            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),
+                }
+            )
+
+        # 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]
+
+    @staticmethod
+    def _calculate_column_widths(
+        terminal_width: int, columns: Dict[str, int]
+    ) -> Dict[str, int]:
+        """Calculate dynamic column widths based on terminal size.
+
+        Args:
+            terminal_width: Current terminal width in characters
+            columns: Dict mapping column names to minimum widths
+
+        Returns:
+            Dict mapping column names to calculated widths
+
+        Design:
+            - Ensures minimum widths are respected
+            - Distributes extra space proportionally
+            - Handles narrow terminals gracefully (minimum 80 chars)
+        """
+        # Ensure minimum terminal width
+        min_terminal_width = 80
+        terminal_width = max(terminal_width, min_terminal_width)
+
+        # Calculate total minimum width needed
+        total_min_width = sum(columns.values())
+
+        # Account for table borders and padding (2 chars per column + 2 for edges)
+        overhead = (len(columns) * 2) + 2
+        available_width = terminal_width - overhead
+
+        # If we have extra space, distribute proportionally
+        if available_width > total_min_width:
+            extra_space = available_width - total_min_width
+            total_weight = sum(columns.values())
+
+            result = {}
+            for col_name, min_width in columns.items():
+                # Distribute extra space based on minimum width proportion
+                proportion = min_width / total_weight
+                extra = int(extra_space * proportion)
+                result[col_name] = min_width + extra
+            return result
+        # Terminal too narrow, use minimum widths
+        return columns.copy()
+
+    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
+
+        # Get terminal width and calculate dynamic column widths
+        terminal_width = shutil.get_terminal_size().columns
+        min_widths = {
+            "#": 4,
+            "Agent ID": 30,
+            "Name": 20,
+            "Source": 15,
+            "Status": 10,
+        }
+        widths = self._calculate_column_widths(terminal_width, min_widths)
+
+        agents_table = Table(show_header=True, header_style="bold white")
+        agents_table.add_column("#", style="dim", width=widths["#"], no_wrap=True)
+        agents_table.add_column(
+            "Agent ID",
+            style="white",
+            width=widths["Agent ID"],
+            no_wrap=True,
+            overflow="ellipsis",
+        )
+        agents_table.add_column(
+            "Name",
+            style="white",
+            width=widths["Name"],
+            no_wrap=True,
+            overflow="ellipsis",
+        )
+        agents_table.add_column(
+            "Source",
+            style="bright_yellow",
+            width=widths["Source"],
+            no_wrap=True,
+        )
+        agents_table.add_column(
+            "Status", style="white", width=widths["Status"], 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)
+
+        # Show installed vs available count
+        installed_count = sum(1 for a in agents if getattr(a, "is_deployed", False))
+        available_count = len(agents) - installed_count
+        self.console.print(
+            f"\n[green]✓ {installed_count} installed[/green] | "
+            f"[dim]{available_count} available[/dim] | "
+            f"[dim]Total: {len(agents)}[/dim]"
+        )
+
+    def _manage_sources(self) -> None:
+        """Interactive source management."""
+        self.console.print("\n[bold white]═══ Manage Agent Sources ═══[/bold white]\n")
+        self.console.print(
+            "[dim]Use 'claude-mpm agent-source' command to add/remove sources[/dim]"
+        )
+        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")
+
+    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
+
+        # 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 (original state - for calculating final changes)
+        # NOTE: deployed_ids contains LEAF NAMES (e.g., "python-engineer")
+        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
+
+        # Build mapping: leaf name -> full path for deployed agents
+        # This allows comparing deployed_ids (leaf names) with agent.name (full paths)
+        deployed_full_paths = set()
+        for agent in agents:
+            agent_leaf_name = agent.name.split("/")[-1]
+            if agent_leaf_name in deployed_ids:
+                deployed_full_paths.add(agent.name)
+
+        # Track current selection state (starts with deployed full paths, updated after each iteration)
+        current_selection = deployed_full_paths.copy()
+
+        # Loop to allow adjusting selection
+        while True:
+            # Build checkbox choices with pre-selection based on current_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 based on current_selection (full paths)
+                    # current_selection contains full paths like "engineer/backend/python-engineer"
+                    is_selected = agent.name in current_selection
+
+                    # 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 based on current_selection
+                    choice = questionary.Choice(
+                        title=choice_text, value=agent.name, checked=is_selected
+                    )
+
+                    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"
+            )
+
+            # Monkey-patch questionary symbols for better visibility
+            # Must patch common module directly since it imports constants at load time
+            questionary.prompts.common.INDICATOR_SELECTED = "[✓]"
+            questionary.prompts.common.INDICATOR_UNSELECTED = "[ ]"
+
+            # Pre-selection via checked=True on Choice objects
+            self.logger.debug(
+                "About to show checkbox selection with %d agents", len(agent_choices)
+            )
+
+            try:
+                selected_agent_ids = questionary.checkbox(
+                    "Agents:", choices=agent_choices, style=self.QUESTIONARY_STYLE
+                ).ask()
+            except Exception as e:
+                # Handle questionary failure (non-TTY, broken pipe, keyboard interrupt, etc.)
+                import sys
+
+                self.logger.error(f"Questionary checkbox failed: {e}", exc_info=True)
+                self.console.print(
+                    "[red]Error: Could not display interactive menu[/red]"
+                )
+                self.console.print(f"[dim]Reason: {e}[/dim]")
+                if not sys.stdin.isatty():
+                    self.console.print("[dim]Interactive terminal required. Use:[/dim]")
+                    self.console.print(
+                        "[dim]  --list-agents to see available agents[/dim]"
+                    )
+                    self.console.print(
+                        "[dim]  --enable-agent/--disable-agent for scripting[/dim]"
+                    )
+                else:
+                    self.console.print(
+                        "[dim]This might be a terminal compatibility issue.[/dim]"
+                    )
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            # Handle Esc OR non-interactive terminal
+            if selected_agent_ids is None:
+                # Check if we're in a non-interactive environment
+                import sys
+
+                if not sys.stdin.isatty():
+                    self.console.print(
+                        "[red]Error: Interactive terminal required for agent selection[/red]"
+                    )
+                    self.console.print(
+                        "[dim]Use --list-agents to see available agents[/dim]"
+                    )
+                    self.console.print(
+                        "[dim]Use --enable-agent/--disable-agent for non-interactive mode[/dim]"
+                    )
+                else:
+                    self.console.print("[yellow]No changes made[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            # Update current_selection based on user's choices (full paths)
+            current_selection = set(selected_agent_ids)
+
+            # Determine actions based on ORIGINAL deployed state
+            # Compare full paths to full paths (deployed_full_paths was built from deployed_ids)
+            to_deploy = (
+                current_selection - deployed_full_paths
+            )  # Selected but not originally deployed
+            to_remove = (
+                deployed_full_paths - current_selection
+            )  # Originally deployed but not selected
+
+            if not to_deploy and not to_remove:
+                self.console.print(
+                    "[yellow]No changes needed - all selected agents are already installed[/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":
+                # current_selection is already updated, loop will use it
+                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]")
+
+            # Remove agents
+            for agent_id in to_remove:
+                try:
+                    import json
+                    from pathlib import Path
+
+                    # 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]")
+
+            # Show summary
+            self.console.print()
+            if deploy_success > 0:
+                self.console.print(
+                    f"[green]✓ Installed {deploy_success} agent(s)[/green]"
+                )
+            if deploy_fail > 0:
+                self.console.print(
+                    f"[red]✗ Failed to install {deploy_fail} agent(s)[/red]"
+                )
+            if remove_success > 0:
+                self.console.print(
+                    f"[green]✓ Removed {remove_success} agent(s)[/green]"
+                )
+            if remove_fail > 0:
+                self.console.print(
+                    f"[red]✗ Failed to remove {remove_fail} agent(s)[/red]"
+                )
+
+            Prompt.ask("\nPress Enter to continue")
+            # Exit the loop after successful execution
+            break
+
+    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
+
+            source_manager = GitSourceManager()
+            preset_service = AgentPresetService(source_manager)
+
+            presets = preset_service.list_presets()
+
+            if not presets:
+                self.console.print("[yellow]No presets available[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            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")
+
+            selection = Prompt.ask("\nEnter preset number (or 'c' to cancel)")
+            if selection.lower() == "c":
+                return
+
+            idx = int(selection) - 1
+            if 0 <= idx < len(presets):
+                preset_name = presets[idx]["name"]
+
+                # Resolve and deploy preset
+                resolution = preset_service.resolve_agents(preset_name)
+
+                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
+
+                # 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
+
+                    self.console.print(
+                        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"\n[white]Installing {full_agent_id}...[/white]"
+                    )
+
+                # Copy the agent file
+                import shutil
+
+                shutil.copy2(source_file, target_file)
+
+                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(
+                    "[yellow]Local template installation not yet implemented[/yellow]"
+                )
+                Prompt.ask("\nPress Enter to continue")
+            return False
+
+        except Exception as 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
+
+        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}")
+
+        selection = Prompt.ask("\nEnter agent number to remove (or 'c' to cancel)")
+        if selection.lower() == "c":
+            return
+
+        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]")
+
+                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
+
+        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}")
+
+        selection = Prompt.ask("\nEnter agent number to view (or 'c' to cancel)")
+        if selection.lower() == "c":
+            return
+
+        try:
+            idx = int(selection) - 1
+            if 0 <= idx < len(agents):
+                agent = agents[idx]
+
+                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")
+
+        except (ValueError, IndexError):
+            self.console.print("[red]Invalid selection[/red]")
+            Prompt.ask("\nPress Enter to continue")
+
 
 def manage_configure(args) -> int:
     """Main entry point for configuration management command.