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

claude_mpm/cli/commands/configure.py

@@ -12,10 +12,13 @@ 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
@@ -23,6 +26,7 @@ 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
@@ -43,13 +47,18 @@ from .configure_validators import (
 class ConfigureCommand(BaseCommand):
     """Interactive configuration management command."""
 
-    # Questionary style matching Rich cyan theme
+    # Questionary style optimized for dark terminals (WCAG AAA compliant)
     QUESTIONARY_STYLE = Style(
         [
-            ("selected", "fg:cyan bold"),
-            ("pointer", "fg:cyan bold"),
-            ("highlighted", "fg:cyan"),
-            ("question", "fg:cyan bold"),
+            ("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
         ]
     )
 
@@ -296,23 +305,33 @@ class ConfigureCommand(BaseCommand):
         return self.navigation.show_main_menu()
 
     def _manage_agents(self) -> None:
-        """Enhanced agent management with remote agent discovery and deployment."""
+        """Enhanced agent management with remote agent discovery and installation."""
         while True:
             self.console.clear()
             self.navigation.display_header()
             self.console.print("\n[bold blue]═══ Agent Management ═══[/bold blue]\n")
 
             # Step 1: Show configured sources
-            self.console.print("[bold cyan]═══ Agent Sources ═══[/bold cyan]\n")
+            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 cyan")
-                sources_table.add_column("Source", style="cyan", width=40)
-                sources_table.add_column("Status", style="green", width=15)
-                sources_table.add_column("Agents", style="yellow", width=10)
+                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
+                )
 
                 for source in sources:
                     status = "✓ Active" if source.get("enabled", True) else "Disabled"
@@ -329,19 +348,29 @@ class ConfigureCommand(BaseCommand):
                 )
 
             # Step 2: Discover and display available agents
-            self.console.print("\n[bold cyan]═══ Available Agents ═══[/bold cyan]\n")
+            self.console.print("\n[bold white]═══ Available Agents ═══[/bold white]\n")
 
             try:
                 # Discover agents (includes both local and remote)
                 agents = self.agent_manager.discover_agents(include_remote=True)
 
+                # 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
+
+                # Filter BASE_AGENT from display (1M-502 Phase 1)
+                agents = self._filter_agent_configs(agents, filter_deployed=False)
+
                 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
+                    # Display agents in a table (already filtered at line 339)
                     self._display_agents_with_source_info(agents)
 
             except Exception as e:
@@ -350,13 +379,14 @@ class ConfigureCommand(BaseCommand):
 
             # 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)",
-                        "Deploy agents (individual selection)",
-                        "Deploy preset (predefined sets)",
+                        "Select Agents",
+                        "Install preset (predefined sets)",
                         "Remove agents",
                         "View agent details",
                         "Toggle agents (legacy enable/disable)",
@@ -374,9 +404,10 @@ class ConfigureCommand(BaseCommand):
                 # Map selection to action
                 if choice == "Manage sources (add/remove repositories)":
                     self._manage_sources()
-                elif choice == "Deploy agents (individual selection)":
+                elif choice == "Select Agents":
+                    self.logger.debug("User selected 'Select Agents' from menu")
                     self._deploy_agents_individual(agents_var)
-                elif choice == "Deploy preset (predefined sets)":
+                elif choice == "Install preset (predefined sets)":
                     self._deploy_agents_preset()
                 elif choice == "Remove agents":
                     self._remove_agents(agents_var)
@@ -388,6 +419,26 @@ class ConfigureCommand(BaseCommand):
             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
 
     def _display_agents_table(self, agents: List[AgentConfig]) -> None:
         """Display a table of available agents."""
@@ -560,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
@@ -603,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 = (
@@ -626,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
@@ -757,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:
@@ -900,41 +957,184 @@ class ConfigureCommand(BaseCommand):
             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 deployment status."""
+        """Display agents table with source information and installation status."""
         from rich.table import Table
 
-        agents_table = Table(show_header=True, header_style="bold cyan")
-        agents_table.add_column("#", style="dim", width=4)
-        agents_table.add_column("Agent ID", style="cyan", width=35)
-        agents_table.add_column("Name", style="green", width=25)
-        agents_table.add_column("Source", style="yellow", width=15)
-        agents_table.add_column("Status", style="magenta", width=12)
+        # 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 type
+            # Determine source with repo name
             source_type = getattr(agent, "source_type", "local")
-            source_label = "Remote" if source_type == "remote" else "Local"
 
-            # Determine deployment status
-            is_deployed = getattr(agent, "is_deployed", False)
-            status = "✓ Deployed" if is_deployed else "Available"
+            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)
-            if len(display_name) > 23:
-                display_name = display_name[:20] + "..."
+            # 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]")
+
+        # 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 cyan]═══ Manage Agent Sources ═══[/bold cyan]\n")
+        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]"
         )
@@ -945,43 +1145,297 @@ class ConfigureCommand(BaseCommand):
         Prompt.ask("\nPress Enter to continue")
 
     def _deploy_agents_individual(self, agents: List[AgentConfig]) -> None:
-        """Deploy agents individually with selection interface."""
+        """Manage agent installation state (unified install/remove interface)."""
         if not agents:
-            self.console.print("[yellow]No agents available for deployment[/yellow]")
+            self.console.print("[yellow]No agents available[/yellow]")
             Prompt.ask("\nPress Enter to continue")
             return
 
-        # Filter to non-deployed agents
-        deployable = [a for a in agents if not getattr(a, "is_deployed", False)]
+        # 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,
+        )
 
-        if not deployable:
-            self.console.print("[yellow]All agents are already deployed[/yellow]")
+        # 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
 
-        self.console.print(f"\n[bold]Deployable agents ({len(deployable)}):[/bold]")
-        for idx, agent in enumerate(deployable, 1):
-            display_name = getattr(agent, "display_name", agent.name)
-            self.console.print(f"  {idx}. {agent.name} - {display_name}")
+        # 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)
 
-        selection = Prompt.ask("\nEnter agent number to deploy (or 'c' to cancel)")
-        if selection.lower() == "c":
-            return
+        # Track current selection state (starts with deployed full paths, updated after each iteration)
+        current_selection = deployed_full_paths.copy()
 
-        try:
-            idx = int(selection) - 1
-            if 0 <= idx < len(deployable):
-                agent = deployable[idx]
-                self._deploy_single_agent(agent)
-            else:
-                self.console.print("[red]Invalid selection[/red]")
+        # 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")
-        except (ValueError, IndexError):
-            self.console.print("[red]Invalid selection[/red]")
+                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:
-        """Deploy agents using preset configuration."""
+        """Install agents using preset configuration."""
         try:
             from claude_mpm.services.agents.agent_preset_service import (
                 AgentPresetService,
@@ -998,9 +1452,9 @@ class ConfigureCommand(BaseCommand):
                 Prompt.ask("\nPress Enter to continue")
                 return
 
-            self.console.print("\n[bold cyan]═══ Available Presets ═══[/bold cyan]\n")
+            self.console.print("\n[bold white]═══ Available Presets ═══[/bold white]\n")
             for idx, preset in enumerate(presets, 1):
-                self.console.print(f"  {idx}. [cyan]{preset['name']}[/cyan]")
+                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")
 
@@ -1024,14 +1478,14 @@ class ConfigureCommand(BaseCommand):
                     Prompt.ask("\nPress Enter to continue")
                     return
 
-                # Confirm deployment
+                # Confirm installation
                 self.console.print(
                     f"\n[bold]Preset '{preset_name}' includes {len(resolution['agents'])} agents[/bold]"
                 )
-                if Confirm.ask("Deploy all agents?", default=True):
-                    deployed = 0
+                if Confirm.ask("Install all agents?", default=True):
+                    installed = 0
                     for agent in resolution["agents"]:
-                        # Convert dict to AgentConfig-like object for deployment
+                        # Convert dict to AgentConfig-like object for installation
                         agent_config = AgentConfig(
                             name=agent.get("agent_id", "unknown"),
                             description=agent.get("metadata", {}).get(
@@ -1043,10 +1497,10 @@ class ConfigureCommand(BaseCommand):
                         agent_config.full_agent_id = agent.get("agent_id", "unknown")
 
                         if self._deploy_single_agent(agent_config, show_feedback=False):
-                            deployed += 1
+                            installed += 1
 
                     self.console.print(
-                        f"\n[green]✓ Deployed {deployed}/{len(resolution['agents'])} agents[/green]"
+                        f"\n[green]✓ Installed {installed}/{len(resolution['agents'])} agents[/green]"
                     )
 
                 Prompt.ask("\nPress Enter to continue")
@@ -1055,14 +1509,14 @@ class ConfigureCommand(BaseCommand):
                 Prompt.ask("\nPress Enter to continue")
 
         except Exception as e:
-            self.console.print(f"[red]Error deploying preset: {e}[/red]")
-            self.logger.error(f"Preset deployment failed: {e}", exc_info=True)
+            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:
-        """Deploy a single agent to the appropriate location."""
+        """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)
@@ -1090,7 +1544,9 @@ class ConfigureCommand(BaseCommand):
                 target_file = target_dir / target_name
 
                 if show_feedback:
-                    self.console.print(f"\n[cyan]Deploying {full_agent_id}...[/cyan]")
+                    self.console.print(
+                        f"\n[white]Installing {full_agent_id}...[/white]"
+                    )
 
                 # Copy the agent file
                 import shutil
@@ -1099,38 +1555,38 @@ class ConfigureCommand(BaseCommand):
 
                 if show_feedback:
                     self.console.print(
-                        f"[green]✓ Successfully deployed {full_agent_id} to {target_file}[/green]"
+                        f"[green]✓ Successfully installed {full_agent_id} to {target_file}[/green]"
                     )
                     Prompt.ask("\nPress Enter to continue")
 
                 return True
-            # Legacy local template deployment (not implemented here)
+            # Legacy local template installation (not implemented here)
             if show_feedback:
                 self.console.print(
-                    "[yellow]Local template deployment not yet implemented[/yellow]"
+                    "[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 deploying agent: {e}[/red]")
-                self.logger.error(f"Agent deployment failed: {e}", exc_info=True)
+                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 deployed agents."""
-        # Filter to deployed agents only
-        deployed = [a for a in agents if getattr(a, "is_deployed", False)]
+        """Remove installed agents."""
+        # Filter to installed agents only
+        installed = [a for a in agents if getattr(a, "is_deployed", False)]
 
-        if not deployed:
-            self.console.print("[yellow]No agents are currently deployed[/yellow]")
+        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]Deployed agents ({len(deployed)}):[/bold]")
-        for idx, agent in enumerate(deployed, 1):
+        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}")
 
@@ -1140,8 +1596,8 @@ class ConfigureCommand(BaseCommand):
 
         try:
             idx = int(selection) - 1
-            if 0 <= idx < len(deployed):
-                agent = deployed[idx]
+            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)
@@ -1207,7 +1663,7 @@ class ConfigureCommand(BaseCommand):
                 agent = agents[idx]
 
                 self.console.clear()
-                self.console.print("\n[bold cyan]═══ Agent Details ═══[/bold cyan]\n")
+                self.console.print("\n[bold white]═══ Agent Details ═══[/bold white]\n")
 
                 # Basic info
                 self.console.print(f"[bold]ID:[/bold] {agent.name}")
@@ -1229,9 +1685,9 @@ class ConfigureCommand(BaseCommand):
                     self.console.print(f"[bold]Source:[/bold] {source}")
                     self.console.print(f"[bold]Version:[/bold] {version[:16]}...")
 
-                # Deployment status
-                is_deployed = getattr(agent, "is_deployed", False)
-                status = "✓ Deployed" if is_deployed else "Available"
+                # 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")