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

claude_mpm/cli/commands/configure.py

@@ -13,18 +13,20 @@ DESIGN DECISIONS:
 
 import json
 import shutil
+from collections import defaultdict
 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 questionary import Choice, Separator, Style
 from rich.console import Console
 from rich.prompt import Confirm, Prompt
 from rich.text import Text
 
 from ...core.config import Config
+from ...services.agents.agent_recommendation_service import AgentRecommendationService
 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
@@ -76,6 +78,7 @@ class ConfigureCommand(BaseCommand):
         self._navigation = None  # Lazy-initialized
         self._template_editor = None  # Lazy-initialized
         self._startup_manager = None  # Lazy-initialized
+        self._recommendation_service = None  # Lazy-initialized
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -152,6 +155,13 @@ class ConfigureCommand(BaseCommand):
             )
         return self._startup_manager
 
+    @property
+    def recommendation_service(self) -> AgentRecommendationService:
+        """Lazy-initialize recommendation service."""
+        if self._recommendation_service is None:
+            self._recommendation_service = AgentRecommendationService()
+        return self._recommendation_service
+
     def run(self, args) -> CommandResult:
         """Execute the configure command."""
         # Set configuration scope
@@ -311,85 +321,28 @@ class ConfigureCommand(BaseCommand):
             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
-                )
-
-                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)
-                    )
+            # Load all agents with spinner (don't show partial state)
+            agents = self._load_agents_with_spinner()
 
-                self.console.print(sources_table)
-            else:
-                self.console.print("[yellow]No agent sources configured[/yellow]")
+            if not agents:
+                self.console.print("[yellow]No agents found[/yellow]")
                 self.console.print(
-                    "[dim]Default source 'bobmatnyc/claude-mpm-agents' will be used[/dim]\n"
+                    "[dim]Configure sources with 'claude-mpm agent-source add'[/dim]\n"
                 )
+                Prompt.ask("\nPress Enter to continue")
+                break
 
-            # Step 2: Discover and display available agents
-            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 (already filtered at line 339)
-                    self._display_agents_with_source_info(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)
+            # Now display everything at once (after all data loaded)
+            self._display_agent_sources_and_list(agents)
 
-            # Step 3: Menu options with arrow-key navigation
+            # Step 3: Simplified menu - only "Select Agents" option
             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",
                     ],
@@ -399,22 +352,11 @@ class ConfigureCommand(BaseCommand):
                 if choice is None or choice == "← Back to main menu":
                     break
 
-                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":
+                if 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)
+                    self._deploy_agents_unified(agents)
+                    # Loop back to show updated state after deployment
 
             except KeyboardInterrupt:
                 self.console.print("\n[yellow]Operation cancelled[/yellow]")
@@ -440,6 +382,86 @@ class ConfigureCommand(BaseCommand):
                 Prompt.ask("\nPress Enter to continue")
                 break
 
+    def _load_agents_with_spinner(self) -> List[AgentConfig]:
+        """Load agents with loading indicator, don't show partial state.
+
+        Returns:
+            List of discovered agents with deployment status set.
+        """
+
+        agents = []
+        with self.console.status(
+            "[bold blue]Loading agents...[/bold blue]", spinner="dots"
+        ):
+            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)
+
+            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)
+                agents = []
+
+        return agents
+
+    def _display_agent_sources_and_list(self, agents: List[AgentConfig]) -> None:
+        """Display agent sources and agent list (only after all data loaded).
+
+        Args:
+            agents: List of discovered agents with deployment status.
+        """
+        from rich.table import Table
+
+        # Step 1: Show configured sources
+        self.console.print("[bold white]═══ Agent Sources ═══[/bold white]\n")
+
+        sources = self._get_configured_sources()
+        if sources:
+            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"
+                agent_count = source.get("agent_count", "?")
+                sources_table.add_row(source["identifier"], status, str(agent_count))
+
+            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"
+            )
+
+        # Step 2: Display available agents
+        self.console.print("\n[bold white]═══ Available Agents ═══[/bold white]\n")
+
+        if agents:
+            # Show progress spinner while recommendation service processes agents
+            with self.console.status(
+                "[bold blue]Preparing agent list...[/bold blue]", spinner="dots"
+            ):
+                self._display_agents_with_source_info(agents)
+        else:
+            self.console.print("[yellow]No agents available[/yellow]")
+
     def _display_agents_table(self, agents: List[AgentConfig]) -> None:
         """Display a table of available agents."""
         self.agent_display.display_agents_table(agents)
@@ -497,6 +519,9 @@ class ConfigureCommand(BaseCommand):
                 if self.agent_manager.has_pending_changes():
                     self.agent_manager.commit_deferred_changes()
                     self.console.print("[green]✓ Changes saved successfully![/green]")
+
+                    # Auto-deploy enabled agents to .claude/agents/
+                    self._auto_deploy_enabled_agents(agents)
                 else:
                     self.console.print("[yellow]No changes to save.[/yellow]")
                 Prompt.ask("Press Enter to continue")
@@ -524,6 +549,60 @@ class ConfigureCommand(BaseCommand):
                             agent.name, not current
                         )
 
+    def _auto_deploy_enabled_agents(self, agents: List[AgentConfig]) -> None:
+        """Auto-deploy enabled agents after saving configuration.
+
+        WHY: When users enable agents, they expect them to be deployed
+        automatically to .claude/agents/ so they're available for use.
+        """
+        try:
+            # Get list of enabled agents from states
+            enabled_agents = [
+                agent
+                for agent in agents
+                if self.agent_manager.is_agent_enabled(agent.name)
+            ]
+
+            if not enabled_agents:
+                return
+
+            # Show deployment progress
+            self.console.print(
+                f"\n[bold blue]Deploying {len(enabled_agents)} enabled agent(s)...[/bold blue]"
+            )
+
+            # Deploy each enabled agent
+            success_count = 0
+            failed_count = 0
+
+            for agent in enabled_agents:
+                # Deploy to .claude/agents/ (project-level)
+                try:
+                    if self._deploy_single_agent(agent, show_feedback=False):
+                        success_count += 1
+                        self.console.print(f"[green]✓ Deployed: {agent.name}[/green]")
+                    else:
+                        failed_count += 1
+                        self.console.print(f"[yellow]⚠ Skipped: {agent.name}[/yellow]")
+                except Exception as e:
+                    failed_count += 1
+                    self.logger.error(f"Failed to deploy {agent.name}: {e}")
+                    self.console.print(f"[red]✗ Failed: {agent.name}[/red]")
+
+            # Show summary
+            if success_count > 0:
+                self.console.print(
+                    f"\n[green]✓ Successfully deployed {success_count} agent(s) to .claude/agents/[/green]"
+                )
+            if failed_count > 0:
+                self.console.print(
+                    f"[yellow]⚠ {failed_count} agent(s) failed or were skipped[/yellow]"
+                )
+
+        except Exception as e:
+            self.logger.error(f"Auto-deployment failed: {e}", exc_info=True)
+            self.console.print(f"[red]✗ Auto-deployment error: {e}[/red]")
+
     def _customize_agent_template(self, agents: List[AgentConfig]) -> None:
         """Customize agent JSON template."""
         self.template_editor.customize_agent_template(agents)
@@ -933,14 +1012,14 @@ class ConfigureCommand(BaseCommand):
                 identifier = repo.identifier
 
                 # Count agents in cache
+                # Note: identifier already includes subdirectory path (e.g., "bobmatnyc/claude-mpm-agents/agents")
                 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")))
+                    # cache_dir IS the agents directory - no need to append /agents
+                    agent_count = len(list(cache_dir.rglob("*.md")))
 
                 sources.append(
                     {
@@ -1038,10 +1117,36 @@ class ConfigureCommand(BaseCommand):
         # Terminal too narrow, use minimum widths
         return columns.copy()
 
+    def _format_display_name(self, name: str) -> str:
+        """Format internal agent name to human-readable display name.
+
+        Converts underscores/hyphens to spaces and title-cases.
+        Examples:
+            agentic_coder_optimizer -> Agentic Coder Optimizer
+            python-engineer -> Python Engineer
+            api_qa_agent -> Api Qa Agent
+
+        Args:
+            name: Internal agent name (may contain underscores, hyphens)
+
+        Returns:
+            Human-readable display name
+        """
+        return name.replace("_", " ").replace("-", " ").title()
+
     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 recommended agents for this project
+        try:
+            recommended_agents = self.recommendation_service.get_recommended_agents(
+                str(self.project_dir)
+            )
+        except Exception as e:
+            self.logger.warning(f"Failed to get recommended agents: {e}")
+            recommended_agents = set()
+
         # Get terminal width and calculate dynamic column widths
         terminal_width = shutil.get_terminal_size().columns
         min_widths = {
@@ -1053,18 +1158,20 @@ class ConfigureCommand(BaseCommand):
         }
         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 = Table(show_header=True, header_style="bold cyan")
+        agents_table.add_column(
+            "#", style="bright_black", width=widths["#"], no_wrap=True
+        )
         agents_table.add_column(
             "Agent ID",
-            style="white",
+            style="bright_black",
             width=widths["Agent ID"],
             no_wrap=True,
             overflow="ellipsis",
         )
         agents_table.add_column(
             "Name",
-            style="white",
+            style="bright_cyan",
             width=widths["Name"],
             no_wrap=True,
             overflow="ellipsis",
@@ -1076,9 +1183,13 @@ class ConfigureCommand(BaseCommand):
             no_wrap=True,
         )
         agents_table.add_column(
-            "Status", style="white", width=widths["Status"], no_wrap=True
+            "Status", style="bright_black", width=widths["Status"], no_wrap=True
         )
 
+        # FIX 3: Get deployed agent IDs once, before the loop (efficiency)
+        deployed_ids = get_deployed_agent_ids()
+
+        recommended_count = 0
         for idx, agent in enumerate(agents, 1):
             # Determine source with repo name
             source_type = getattr(agent, "source_type", "local")
@@ -1106,29 +1217,76 @@ class ConfigureCommand(BaseCommand):
             else:
                 source_label = "Local"
 
-            # Determine installation status (removed symbols for cleaner look)
-            is_installed = getattr(agent, "is_deployed", False)
+            # FIX 2: Check actual deployment status from .claude/agents/ directory
+            is_installed = agent.name in deployed_ids
             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
+            # Check if agent is recommended
+            # Handle both hierarchical paths (e.g., "engineer/backend/python-engineer")
+            # and leaf names (e.g., "python-engineer")
+            agent_full_path = agent.name
+            agent_leaf_name = (
+                agent_full_path.split("/")[-1]
+                if "/" in agent_full_path
+                else agent_full_path
+            )
+
+            for recommended_id in recommended_agents:
+                # Check if the recommended_id matches either the full path or just the leaf name
+                recommended_leaf = (
+                    recommended_id.split("/")[-1]
+                    if "/" in recommended_id
+                    else recommended_id
+                )
+                if (
+                    agent_full_path == recommended_id
+                    or agent_leaf_name == recommended_leaf
+                ):
+                    recommended_count += 1
+                    break
+
+            # FIX 1: Removed asterisk - using Status column instead
+            agent_id_display = agent.name
+
+            # Get display name and format it properly
+            # Raw display_name from YAML may contain underscores (e.g., "agentic_coder_optimizer")
+            raw_display_name = getattr(agent, "display_name", agent.name)
+            display_name = self._format_display_name(raw_display_name)
 
             agents_table.add_row(
-                str(idx), agent.name, display_name, source_label, status
+                str(idx), agent_id_display, 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))
+        # Show legend if there are recommended agents
+        if recommended_count > 0:
+            # Get detection summary for context
+            try:
+                summary = self.recommendation_service.get_detection_summary(
+                    str(self.project_dir)
+                )
+                detected_langs = (
+                    ", ".join(summary.get("detected_languages", [])) or "None"
+                )
+                ", ".join(summary.get("detected_frameworks", [])) or "None"
+                self.console.print(
+                    f"\n[dim]* = recommended for this project "
+                    f"(detected: {detected_langs})[/dim]"
+                )
+            except Exception:
+                self.console.print("\n[dim]* = recommended for this project[/dim]")
+
+        # Show installed vs available count (use deployed_ids for accuracy)
+        installed_count = sum(1 for a in agents if a.name in deployed_ids)
         available_count = len(agents) - installed_count
         self.console.print(
             f"\n[green]✓ {installed_count} installed[/green] | "
             f"[dim]{available_count} available[/dim] | "
+            f"[yellow]{recommended_count} recommended[/yellow] | "
             f"[dim]Total: {len(agents)}[/dim]"
         )
 
@@ -1144,8 +1302,423 @@ class ConfigureCommand(BaseCommand):
         self.console.print("  claude-mpm agent-source list")
         Prompt.ask("\nPress Enter to continue")
 
+    def _deploy_agents_unified(self, agents: List[AgentConfig]) -> None:
+        """Unified agent selection with inline controls for recommended, presets, and collections.
+
+        Design:
+        - Single nested checkbox list with grouped agents by source/category
+        - Inline controls at top: Select all, Select recommended, Select presets
+        - Asterisk (*) marks recommended agents
+        - Visual hierarchy: Source → Category → Individual agents
+        - Loop with visual feedback: Controls update checkmarks immediately
+        """
+        if not agents:
+            self.console.print("[yellow]No agents available[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        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
+            ]
+        )
+
+        if not all_agents:
+            self.console.print("[yellow]No agents available[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Get deployed agent IDs and recommended agents
+        deployed_ids = get_deployed_agent_ids()
+
+        try:
+            recommended_agent_ids = self.recommendation_service.get_recommended_agents(
+                str(self.project_dir)
+            )
+        except Exception as e:
+            self.logger.warning(f"Failed to get recommended agents: {e}")
+            recommended_agent_ids = set()
+
+        # Build mapping: leaf name -> full path for deployed agents
+        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, updated in loop)
+        current_selection = deployed_full_paths.copy()
+
+        # Group agents by source/collection
+        agent_map = {}
+        collections = defaultdict(list)
+
+        for agent in agents:
+            if agent.name in {a["agent_id"] for a in all_agents}:
+                # Determine collection ID
+                source_type = getattr(agent, "source_type", "local")
+                if source_type == "remote":
+                    source_dict = getattr(agent, "source_dict", {})
+                    repo_url = source_dict.get("source", "")
+                    if "/" in repo_url:
+                        parts = repo_url.rstrip("/").split("/")
+                        if len(parts) >= 2:
+                            # Use more readable collection name
+                            if (
+                                "bobmatnyc/claude-mpm" in repo_url
+                                or "claude-mpm" in repo_url.lower()
+                            ):
+                                collection_id = "MPM Agents"
+                            else:
+                                collection_id = f"{parts[-2]}/{parts[-1]}"
+                        else:
+                            collection_id = "Community Agents"
+                    else:
+                        collection_id = "Community Agents"
+                else:
+                    collection_id = "Local Agents"
+
+                collections[collection_id].append(agent)
+                agent_map[agent.name] = agent
+
+        # Monkey-patch questionary symbols for better visibility
+        questionary.prompts.common.INDICATOR_SELECTED = "[✓]"
+        questionary.prompts.common.INDICATOR_UNSELECTED = "[ ]"
+
+        # MAIN LOOP: Re-display UI when controls are used
+        while True:
+            # Build unified checkbox choices with inline controls
+            choices = []
+
+            for collection_id in sorted(collections.keys()):
+                agents_in_collection = collections[collection_id]
+
+                # Count selected/total agents in collection
+                selected_count = sum(
+                    1
+                    for agent in agents_in_collection
+                    if agent.name in current_selection
+                )
+                total_count = len(agents_in_collection)
+
+                # Add collection header
+                choices.append(
+                    Separator(
+                        f"\n── {collection_id} ({selected_count}/{total_count} selected) ──"
+                    )
+                )
+
+                # Determine if all agents in collection are selected
+                all_selected = selected_count == total_count
+
+                # Add inline control: Select/Deselect all from this collection
+                if all_selected:
+                    choices.append(
+                        Choice(
+                            f"  [Deselect all from {collection_id}]",
+                            value=f"__DESELECT_ALL_{collection_id}__",
+                            checked=False,
+                        )
+                    )
+                else:
+                    choices.append(
+                        Choice(
+                            f"  [Select all from {collection_id}]",
+                            value=f"__SELECT_ALL_{collection_id}__",
+                            checked=False,
+                        )
+                    )
+
+                # Add inline control: Select recommended from this collection
+                recommended_in_collection = [
+                    a
+                    for a in agents_in_collection
+                    if any(
+                        a.name == rec_id
+                        or a.name.split("/")[-1] == rec_id.split("/")[-1]
+                        for rec_id in recommended_agent_ids
+                    )
+                ]
+                if recommended_in_collection:
+                    recommended_selected = sum(
+                        1
+                        for a in recommended_in_collection
+                        if a.name in current_selection
+                    )
+                    if recommended_selected == len(recommended_in_collection):
+                        choices.append(
+                            Choice(
+                                f"  [Deselect recommended ({len(recommended_in_collection)} agents)]",
+                                value=f"__DESELECT_REC_{collection_id}__",
+                                checked=False,
+                            )
+                        )
+                    else:
+                        choices.append(
+                            Choice(
+                                f"  [Select recommended ({len(recommended_in_collection)} agents)]",
+                                value=f"__SELECT_REC_{collection_id}__",
+                                checked=False,
+                            )
+                        )
+
+                # Add separator before individual agents
+                choices.append(Separator())
+
+                # Group agents by category within collection (if hierarchical)
+                category_groups = defaultdict(list)
+                for agent in sorted(agents_in_collection, key=lambda a: a.name):
+                    # Extract category from hierarchical path (e.g., "engineer/backend/python-engineer")
+                    parts = agent.name.split("/")
+                    if len(parts) > 1:
+                        category = "/".join(parts[:-1])  # e.g., "engineer/backend"
+                    else:
+                        category = ""  # No category
+                    category_groups[category].append(agent)
+
+                # Display agents grouped by category
+                for category in sorted(category_groups.keys()):
+                    agents_in_category = category_groups[category]
+
+                    # Add category separator if hierarchical
+                    if category:
+                        choices.append(Separator(f"  {category}/"))
+
+                    # Add individual agents
+                    for agent in agents_in_category:
+                        agent_leaf_name = agent.name.split("/")[-1]
+                        display_name = getattr(agent, "display_name", agent_leaf_name)
+
+                        # Check if agent is deployed (exists in .claude/agents/)
+
+                        # Format choice text (no asterisk needed)
+                        choice_text = f"    {display_name}"
+
+                        is_selected = agent.name in current_selection
+
+                        choices.append(
+                            Choice(
+                                title=choice_text,
+                                value=agent.name,
+                                checked=is_selected,
+                            )
+                        )
+
+            self.console.print("\n[bold cyan]Select Agents to Install[/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[/dim]\n"
+            )
+
+            try:
+                selected_values = questionary.checkbox(
+                    "Select agents:",
+                    choices=choices,
+                    instruction="(Space to toggle, Enter to continue)",
+                    style=self.QUESTIONARY_STYLE,
+                ).ask()
+            except Exception as e:
+                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]"
+                    )
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            if selected_values is None:
+                self.console.print("[yellow]No changes made[/yellow]")
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            # Check for inline control selections
+            controls_selected = [v for v in selected_values if v.startswith("__")]
+
+            if controls_selected:
+                # Process controls and update current_selection
+                for control in controls_selected:
+                    if control.startswith("__SELECT_ALL_"):
+                        collection_id = control.replace("__SELECT_ALL_", "").replace(
+                            "__", ""
+                        )
+                        # Add all agents from this collection to current_selection
+                        for agent in collections[collection_id]:
+                            current_selection.add(agent.name)
+                    elif control.startswith("__DESELECT_ALL_"):
+                        collection_id = control.replace("__DESELECT_ALL_", "").replace(
+                            "__", ""
+                        )
+                        # Remove all agents from this collection
+                        for agent in collections[collection_id]:
+                            current_selection.discard(agent.name)
+                    elif control.startswith("__SELECT_REC_"):
+                        collection_id = control.replace("__SELECT_REC_", "").replace(
+                            "__", ""
+                        )
+                        # Add all recommended agents from this collection
+                        for agent in collections[collection_id]:
+                            if any(
+                                agent.name == rec_id
+                                or agent.name.split("/")[-1] == rec_id.split("/")[-1]
+                                for rec_id in recommended_agent_ids
+                            ):
+                                current_selection.add(agent.name)
+                    elif control.startswith("__DESELECT_REC_"):
+                        collection_id = control.replace("__DESELECT_REC_", "").replace(
+                            "__", ""
+                        )
+                        # Remove all recommended agents from this collection
+                        for agent in collections[collection_id]:
+                            if any(
+                                agent.name == rec_id
+                                or agent.name.split("/")[-1] == rec_id.split("/")[-1]
+                                for rec_id in recommended_agent_ids
+                            ):
+                                current_selection.discard(agent.name)
+
+                # Loop back to re-display with updated selections
+                continue
+
+            # No controls selected - use the individual selections as final
+            final_selection = set(selected_values)
+            break
+
+        # Determine changes
+        to_deploy = final_selection - deployed_full_paths
+        to_remove = deployed_full_paths - final_selection
+
+        if not to_deploy and not to_remove:
+            self.console.print("[yellow]No changes needed[/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}")
+
+        # Confirm
+        if not Confirm.ask("\nApply these changes?", default=True):
+            self.console.print("[yellow]Changes cancelled[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # 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
+
+                # Extract leaf name to match deployed filename
+                leaf_name = agent_id.split("/")[-1] if "/" in agent_id else agent_id
+
+                # Remove from all possible locations
+                paths_to_check = [
+                    Path.cwd() / ".claude-mpm" / "agents" / f"{leaf_name}.md",
+                    Path.cwd() / ".claude" / "agents" / f"{leaf_name}.md",
+                    Path.home() / ".claude" / "agents" / f"{leaf_name}.md",
+                ]
+
+                removed = False
+                for path in paths_to_check:
+                    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)
+                            agents_in_state = state.get("last_check_results", {}).get(
+                                "agents", {}
+                            )
+                            if leaf_name in agents_in_state:
+                                del agents_in_state[leaf_name]
+                                removed = True
+                                with state_path.open("w") as f:
+                                    json.dump(state, f, indent=2)
+                        except (json.JSONDecodeError, KeyError):
+                            pass
+
+                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")
+
     def _deploy_agents_individual(self, agents: List[AgentConfig]) -> None:
-        """Manage agent installation state (unified install/remove interface)."""
+        """Manage agent installation state (unified install/remove interface).
+
+        DEPRECATED: Use _deploy_agents_unified instead.
+        This method is kept for backward compatibility but should not be used.
+        """
         if not agents:
             self.console.print("[yellow]No agents available[/yellow]")
             Prompt.ask("\nPress Enter to continue")
@@ -1192,59 +1765,91 @@ class ConfigureCommand(BaseCommand):
 
         # Loop to allow adjusting selection
         while True:
-            # Build checkbox choices with pre-selection based on current_selection
-            agent_choices = []
+            # Build agent mapping and collections
             agent_map = {}  # For lookup after selection
+            collections = defaultdict(list)
 
             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
-                    )
+                    # Determine collection ID
+                    source_type = getattr(agent, "source_type", "local")
+                    if source_type == "remote":
+                        source_dict = getattr(agent, "source_dict", {})
+                        repo_url = source_dict.get("source", "")
+                        # Extract repository name from URL
+                        if "/" in repo_url:
+                            parts = repo_url.rstrip("/").split("/")
+                            if len(parts) >= 2:
+                                collection_id = f"{parts[-2]}/{parts[-1]}"
+                            else:
+                                collection_id = "remote"
+                        else:
+                            collection_id = "remote"
+                    else:
+                        collection_id = "local"
 
-                    agent_choices.append(choice)
+                    collections[collection_id].append(agent)
                     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]")
+            # STEP 1: Collection-level selection
+            self.console.print("\n[bold cyan]Select Agent Collections[/bold cyan]")
             self.console.print(
-                "[dim][ ] Unchecked = Available (check to install)[/dim]"
+                "[dim]Checking a collection installs ALL agents in that collection[/dim]"
+            )
+            self.console.print(
+                "[dim]Unchecking a collection removes ALL agents in that collection[/dim]"
             )
             self.console.print(
-                "[dim]Use arrow keys to navigate, space to toggle, "
-                "Enter to apply changes[/dim]\n"
+                "[dim]For partial deployment, use 'Fine-tune individual agents'[/dim]\n"
+            )
+
+            collection_choices = []
+            for collection_id in sorted(collections.keys()):
+                agents_in_collection = collections[collection_id]
+
+                # Check if ANY agent in this collection is currently deployed
+                # This reflects actual deployment state, not just selection
+                any_deployed = any(
+                    agent.name in current_selection for agent in agents_in_collection
+                )
+
+                # Count deployed agents for display
+                deployed_count = sum(
+                    1
+                    for agent in agents_in_collection
+                    if agent.name in current_selection
+                )
+
+                collection_choices.append(
+                    Choice(
+                        f"{collection_id} ({deployed_count}/{len(agents_in_collection)} deployed)",
+                        value=collection_id,
+                        checked=any_deployed,
+                    )
+                )
+
+            # Add option to fine-tune individual agents
+            collection_choices.append(Separator())
+            collection_choices.append(
+                Choice(
+                    "→ Fine-tune individual agents...",
+                    value="__INDIVIDUAL__",
+                    checked=False,
+                )
             )
 
             # 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
+                selected_collections = questionary.checkbox(
+                    "Select agent collections to deploy:",
+                    choices=collection_choices,
+                    instruction="(Space to toggle, Enter to continue)",
+                    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)
@@ -1267,9 +1872,8 @@ class ConfigureCommand(BaseCommand):
                 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
+            # Handle cancellation
+            if selected_collections is None:
                 import sys
 
                 if not sys.stdin.isatty():
@@ -1287,17 +1891,138 @@ class ConfigureCommand(BaseCommand):
                 Prompt.ask("\nPress Enter to continue")
                 return
 
-            # Update current_selection based on user's choices (full paths)
-            current_selection = set(selected_agent_ids)
+            # STEP 2: Check if user wants individual selection
+            if "__INDIVIDUAL__" in selected_collections:
+                # Remove the __INDIVIDUAL__ marker
+                selected_collections = [
+                    c for c in selected_collections if c != "__INDIVIDUAL__"
+                ]
+
+                # Build individual agent choices with grouping
+                agent_choices = []
+                for collection_id in sorted(collections.keys()):
+                    agents_in_collection = collections[collection_id]
+
+                    # Add collection header separator
+                    agent_choices.append(
+                        Separator(
+                            f"\n── {collection_id} ({len(agents_in_collection)} agents) ──"
+                        )
+                    )
+
+                    # Add individual agents from this collection
+                    for agent in sorted(agents_in_collection, key=lambda a: a.name):
+                        display_name = getattr(agent, "display_name", agent.name)
+                        is_selected = agent.name in deployed_full_paths
+
+                        choice_text = f"{agent.name}"
+                        if display_name and display_name != agent.name:
+                            choice_text += f" - {display_name}"
+
+                        agent_choices.append(
+                            Choice(
+                                title=choice_text, value=agent.name, checked=is_selected
+                            )
+                        )
+
+                self.console.print(
+                    "\n[bold cyan]Fine-tune Individual Agents[/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[/dim]\n"
+                )
+
+                try:
+                    selected_agent_ids = questionary.checkbox(
+                        "Select individual agents:",
+                        choices=agent_choices,
+                        style=self.QUESTIONARY_STYLE,
+                    ).ask()
+                except Exception as e:
+                    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]")
+                    Prompt.ask("\nPress Enter to continue")
+                    return
+
+                if selected_agent_ids is None:
+                    self.console.print("[yellow]No changes made[/yellow]")
+                    Prompt.ask("\nPress Enter to continue")
+                    return
+
+                # Update current_selection with individual selections
+                current_selection = set(selected_agent_ids)
+            else:
+                # Apply collection-level selections
+                # For each collection, if it's selected, include ALL its agents
+                # If it's not selected, exclude ALL its agents
+                final_selections = set()
+                for collection_id in selected_collections:
+                    for agent in collections[collection_id]:
+                        final_selections.add(agent.name)
+
+                # Update current_selection
+                # This replaces the previous selection entirely with the new collection selections
+                current_selection = final_selections
 
             # 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
+
+            # For removal, verify files actually exist before adding to the set
+            # This prevents "Not found" warnings when multiple agents share leaf names
+            to_remove = set()
+            for agent_id in deployed_full_paths - current_selection:
+                # Extract leaf name to check file existence
+                leaf_name = agent_id.split("/")[-1] if "/" in agent_id else agent_id
+
+                # Check all possible locations
+                paths_to_check = [
+                    Path.cwd() / ".claude-mpm" / "agents" / f"{leaf_name}.md",
+                    Path.cwd() / ".claude" / "agents" / f"{leaf_name}.md",
+                    Path.home() / ".claude" / "agents" / f"{leaf_name}.md",
+                ]
+
+                # Also check virtual deployment state
+                state_exists = False
+                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:
+                            import json
+
+                            with state_path.open() as f:
+                                state = json.load(f)
+                            agents_in_state = state.get("last_check_results", {}).get(
+                                "agents", {}
+                            )
+                            if leaf_name in agents_in_state:
+                                state_exists = True
+                                break
+                        except (json.JSONDecodeError, KeyError):
+                            continue
+
+                # Only add to removal set if file or state entry actually exists
+                if any(p.exists() for p in paths_to_check) or state_exists:
+                    to_remove.add(agent_id)
 
             if not to_deploy and not to_remove:
                 self.console.print(
@@ -1357,14 +2082,22 @@ class ConfigureCommand(BaseCommand):
             for agent_id in to_remove:
                 try:
                     import json
-                    from pathlib import Path
+                    # Note: Path is already imported at module level (line 17)
+
+                    # Extract leaf name to match deployed filename
+                    # agent_id may be hierarchical (e.g., "engineer/mobile/tauri-engineer")
+                    # but deployed files use flattened leaf names (e.g., "tauri-engineer.md")
+                    if "/" in agent_id:
+                        leaf_name = agent_id.split("/")[-1]
+                    else:
+                        leaf_name = agent_id
 
                     # Remove from project, legacy, and user locations
                     project_path = (
-                        Path.cwd() / ".claude-mpm" / "agents" / f"{agent_id}.md"
+                        Path.cwd() / ".claude-mpm" / "agents" / f"{leaf_name}.md"
                     )
-                    legacy_path = Path.cwd() / ".claude" / "agents" / f"{agent_id}.md"
-                    user_path = Path.home() / ".claude" / "agents" / f"{agent_id}.md"
+                    legacy_path = Path.cwd() / ".claude" / "agents" / f"{leaf_name}.md"
+                    user_path = Path.home() / ".claude" / "agents" / f"{leaf_name}.md"
 
                     removed = False
                     for path in [project_path, legacy_path, user_path]:
@@ -1385,11 +2118,12 @@ class ConfigureCommand(BaseCommand):
                                     state = json.load(f)
 
                                 # Remove agent from deployment state
+                                # Deployment state uses leaf names, not full hierarchical paths
                                 agents = state.get("last_check_results", {}).get(
                                     "agents", {}
                                 )
-                                if agent_id in agents:
-                                    del agents[agent_id]
+                                if leaf_name in agents:
+                                    del agents[leaf_name]
                                     removed = True
 
                                     # Save updated state
@@ -1513,6 +2247,169 @@ class ConfigureCommand(BaseCommand):
             self.logger.error(f"Preset installation failed: {e}", exc_info=True)
             Prompt.ask("\nPress Enter to continue")
 
+    def _select_recommended_agents(self, agents: List[AgentConfig]) -> None:
+        """Select and install recommended agents based on toolchain detection."""
+        if not agents:
+            self.console.print("[yellow]No agents available[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        self.console.clear()
+        self.console.print(
+            "\n[bold white]═══ Recommended Agents for This Project ═══[/bold white]\n"
+        )
+
+        # Get recommended agent IDs
+        try:
+            recommended_agent_ids = self.recommendation_service.get_recommended_agents(
+                str(self.project_dir)
+            )
+        except Exception as e:
+            self.console.print(f"[red]Error detecting toolchain: {e}[/red]")
+            self.logger.error(f"Toolchain detection failed: {e}", exc_info=True)
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        if not recommended_agent_ids:
+            self.console.print("[yellow]No recommended agents found[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Get detection summary
+        try:
+            summary = self.recommendation_service.get_detection_summary(
+                str(self.project_dir)
+            )
+
+            self.console.print("[bold]Detected Project Stack:[/bold]")
+            if summary.get("detected_languages"):
+                self.console.print(
+                    f"  Languages: [cyan]{', '.join(summary['detected_languages'])}[/cyan]"
+                )
+            if summary.get("detected_frameworks"):
+                self.console.print(
+                    f"  Frameworks: [cyan]{', '.join(summary['detected_frameworks'])}[/cyan]"
+                )
+            self.console.print(
+                f"  Detection Quality: [{'green' if summary.get('detection_quality') == 'high' else 'yellow'}]{summary.get('detection_quality', 'unknown')}[/]"
+            )
+            self.console.print()
+        except Exception:
+            pass
+
+        # Build mapping: agent_id -> AgentConfig
+        agent_map = {agent.name: agent for agent in agents}
+
+        # Also check leaf names for matching
+        for agent in agents:
+            leaf_name = agent.name.split("/")[-1] if "/" in agent.name else agent.name
+            if leaf_name not in agent_map:
+                agent_map[leaf_name] = agent
+
+        # Find matching agents from available agents
+        matched_agents = []
+        for recommended_id in recommended_agent_ids:
+            # Try full path match first
+            if recommended_id in agent_map:
+                matched_agents.append(agent_map[recommended_id])
+            else:
+                # Try leaf name match
+                recommended_leaf = (
+                    recommended_id.split("/")[-1]
+                    if "/" in recommended_id
+                    else recommended_id
+                )
+                if recommended_leaf in agent_map:
+                    matched_agents.append(agent_map[recommended_leaf])
+
+        if not matched_agents:
+            self.console.print(
+                "[yellow]No matching agents found in available sources[/yellow]"
+            )
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Display recommended agents
+        self.console.print(
+            f"[bold]Recommended Agents ({len(matched_agents)}):[/bold]\n"
+        )
+
+        from rich.table import Table
+
+        rec_table = Table(show_header=True, header_style="bold white")
+        rec_table.add_column("#", style="dim", width=4)
+        rec_table.add_column("Agent ID", style="cyan", width=40)
+        rec_table.add_column("Status", style="white", width=15)
+
+        for idx, agent in enumerate(matched_agents, 1):
+            is_installed = getattr(agent, "is_deployed", False)
+            status = (
+                "[green]Already Installed[/green]"
+                if is_installed
+                else "[yellow]Not Installed[/yellow]"
+            )
+            rec_table.add_row(str(idx), agent.name, status)
+
+        self.console.print(rec_table)
+
+        # Count how many need installation
+        to_install = [a for a in matched_agents if not getattr(a, "is_deployed", False)]
+        already_installed = len(matched_agents) - len(to_install)
+
+        self.console.print()
+        if already_installed > 0:
+            self.console.print(
+                f"[green]✓ {already_installed} already installed[/green]"
+            )
+        if to_install:
+            self.console.print(
+                f"[yellow]⚠ {len(to_install)} need installation[/yellow]"
+            )
+        else:
+            self.console.print(
+                "[green]✓ All recommended agents are already installed![/green]"
+            )
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Ask for confirmation
+        self.console.print()
+        if not Confirm.ask(
+            f"Install {len(to_install)} recommended agent(s)?", default=True
+        ):
+            self.console.print("[yellow]Installation cancelled[/yellow]")
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Install agents
+        self.console.print("\n[bold]Installing recommended agents...[/bold]\n")
+
+        success_count = 0
+        fail_count = 0
+
+        for agent in to_install:
+            try:
+                if self._deploy_single_agent(agent, show_feedback=False):
+                    success_count += 1
+                    self.console.print(f"[green]✓ Installed: {agent.name}[/green]")
+                else:
+                    fail_count += 1
+                    self.console.print(f"[red]✗ Failed: {agent.name}[/red]")
+            except Exception as e:
+                fail_count += 1
+                self.console.print(f"[red]✗ Failed: {agent.name} - {e}[/red]")
+
+        # Show summary
+        self.console.print()
+        if success_count > 0:
+            self.console.print(
+                f"[green]✓ Successfully installed {success_count} agent(s)[/green]"
+            )
+        if fail_count > 0:
+            self.console.print(f"[red]✗ Failed to install {fail_count} agent(s)[/red]")
+
+        Prompt.ask("\nPress Enter to continue")
+
     def _deploy_single_agent(
         self, agent: AgentConfig, show_feedback: bool = True
     ) -> bool:
@@ -1538,8 +2435,8 @@ class ConfigureCommand(BaseCommand):
                 else:
                     target_name = full_agent_id + ".md"
 
-                # Deploy to user-level agents directory
-                target_dir = Path.home() / ".claude" / "agents"
+                # Deploy to project-level agents directory
+                target_dir = self.project_dir / ".claude" / "agents"
                 target_dir.mkdir(parents=True, exist_ok=True)
                 target_file = target_dir / target_name