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

claude_mpm/cli/commands/configure.py

@@ -12,16 +12,22 @@ DESIGN DECISIONS:
 """
 
 import json
+import shutil
+from collections import defaultdict
 from pathlib import Path
 from typing import Dict, List, Optional
 
 import questionary
-from questionary import Style
+import questionary.constants
+import questionary.prompts.common  # For checkbox symbol customization
+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 ...core.unified_config import UnifiedConfig
+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
@@ -73,6 +79,8 @@ 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
+        self._unified_config = None  # Lazy-initialized
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -149,6 +157,25 @@ 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
+
+    @property
+    def unified_config(self) -> UnifiedConfig:
+        """Lazy-initialize unified config."""
+        if self._unified_config is None:
+            try:
+                self._unified_config = UnifiedConfig()
+            except Exception as e:
+                self.logger.warning(f"Failed to load unified config: {e}")
+                # Fallback to default config
+                self._unified_config = UnifiedConfig()
+        return self._unified_config
+
     def run(self, args) -> CommandResult:
         """Execute the configure command."""
         # Set configuration scope
@@ -308,45 +335,78 @@ 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")
+            # Load all agents with spinner (don't show partial state)
+            agents = self._load_agents_with_spinner()
 
-            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
+            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"
                 )
+                Prompt.ask("\nPress Enter to continue")
+                break
+
+            # Now display everything at once (after all data loaded)
+            self._display_agent_sources_and_list(agents)
+
+            # 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=[
+                        "Select Agents",
+                        questionary.Separator(),
+                        "← Back to main menu",
+                    ],
+                    style=self.QUESTIONARY_STYLE,
+                ).ask()
+
+                if choice is None or choice == "← Back to main menu":
+                    break
+
+                # Map selection to action
+                if choice == "Select Agents":
+                    self.logger.debug("User selected 'Select Agents' from menu")
+                    self._deploy_agents_unified(agents)
+                    # Loop back to show updated state after deployment
+
+            except KeyboardInterrupt:
+                self.console.print("\n[yellow]Operation cancelled[/yellow]")
+                break
+            except Exception as e:
+                # Handle questionary menu failure
+                import sys
 
-                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.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
 
-                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"
-                )
+    def _load_agents_with_spinner(self) -> List[AgentConfig]:
+        """Load agents with loading indicator, don't show partial state.
 
-            # Step 2: Discover and display available agents
-            self.console.print("\n[bold white]═══ Available Agents ═══[/bold white]\n")
+        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)
@@ -354,66 +414,68 @@ class ConfigureCommand(BaseCommand):
                 # 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]
+                    # Use agent_id (technical ID) for comparison, not display name
+                    agent_id = getattr(agent, "agent_id", agent.name)
+                    agent_leaf_name = agent_id.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)
+                agents = []
 
-            # Step 3: Menu options with arrow-key navigation
-            self.console.print()
-            try:
-                choice = questionary.select(
-                    "Agent Management:",
-                    choices=[
-                        "Manage sources (add/remove repositories)",
-                        "Select Agents",
-                        "Install preset (predefined sets)",
-                        "Remove agents",
-                        "View agent details",
-                        "Toggle agents (legacy enable/disable)",
-                        questionary.Separator(),
-                        "← Back to main menu",
-                    ],
-                    style=self.QUESTIONARY_STYLE,
-                ).ask()
+        return agents
 
-                if choice is None or choice == "← Back to main menu":
-                    break
+    def _display_agent_sources_and_list(self, agents: List[AgentConfig]) -> None:
+        """Display agent sources and agent list (only after all data loaded).
 
-                agents_var = agents if "agents" in locals() else []
+        Args:
+            agents: List of discovered agents with deployment status.
+        """
+        from rich.table import Table
 
-                # Map selection to action
-                if choice == "Manage sources (add/remove repositories)":
-                    self._manage_sources()
-                elif choice == "Select Agents":
-                    self._deploy_agents_individual(agents_var)
-                elif choice == "Install preset (predefined sets)":
-                    self._deploy_agents_preset()
-                elif choice == "Remove agents":
-                    self._remove_agents(agents_var)
-                elif choice == "View agent details":
-                    self._view_agent_details_enhanced(agents_var)
-                elif choice == "Toggle agents (legacy enable/disable)":
-                    self._toggle_agents_interactive(agents_var)
+        # 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)
 
-            except KeyboardInterrupt:
-                self.console.print("\n[yellow]Operation cancelled[/yellow]")
-                break
+            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."""
@@ -472,6 +534,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")
@@ -499,6 +564,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)
@@ -551,7 +670,7 @@ class ConfigureCommand(BaseCommand):
         self.behavior_manager.manage_behaviors()
 
     def _manage_skills(self) -> None:
-        """Skills management interface."""
+        """Skills management interface with questionary checkbox selection."""
         from ...cli.interactive.skills_wizard import SkillsWizard
         from ...skills.skill_manager import get_manager
 
@@ -562,22 +681,22 @@ class ConfigureCommand(BaseCommand):
             self.console.clear()
             self._display_header()
 
-            self.console.print("\n[bold]Skills Management Options:[/bold]\n")
-            self.console.print("  [1] View Available Skills")
-            self.console.print("  [2] Configure Skills for Agents")
-            self.console.print("  [3] View Current Skill Mappings")
-            self.console.print("  [4] Auto-Link Skills to Agents")
-            self.console.print("  [b] Back to Main Menu")
+            self.console.print("\n[bold]Skills Management[/bold]")
+
+            # Show action options
+            self.console.print("\n[bold]Actions:[/bold]")
+            self.console.print("  [1] Install/Uninstall skills")
+            self.console.print("  [2] Configure skills for agents")
+            self.console.print("  [3] View current skill mappings")
+            self.console.print("  [4] Auto-link skills to agents")
+            self.console.print("  [b] Back to main menu")
             self.console.print()
 
             choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
             if choice == "1":
-                # View available skills
-                self.console.clear()
-                self._display_header()
-                wizard.list_available_skills()
-                Prompt.ask("\nPress Enter to continue")
+                # Install/Uninstall skills with category-based selection
+                self._manage_skill_installation()
 
             elif choice == "2":
                 # Configure skills interactively
@@ -700,6 +819,548 @@ class ConfigureCommand(BaseCommand):
                 self.console.print("[red]Invalid choice. Please try again.[/red]")
                 Prompt.ask("\nPress Enter to continue")
 
+    def _detect_skill_patterns(self, skills: list[dict]) -> dict[str, list[dict]]:
+        """Group skills by detected common prefixes.
+
+        Args:
+            skills: List of skill dictionaries
+
+        Returns:
+            Dict mapping pattern prefix to list of skills.
+            Skills without pattern match go under "" (empty string) key.
+        """
+        from collections import defaultdict
+
+        # Count prefix occurrences (try 1-segment and 2-segment prefixes)
+        prefix_counts = defaultdict(list)
+
+        for skill in skills:
+            skill_id = skill.get("name", skill.get("skill_id", ""))
+
+            # Try to extract prefixes (split by hyphen)
+            parts = skill_id.split("-")
+
+            if len(parts) >= 2:
+                # Try 2-segment prefix first (e.g., "toolchains-universal")
+                two_seg_prefix = f"{parts[0]}-{parts[1]}"
+                prefix_counts[two_seg_prefix].append(skill)
+
+                # Also try 1-segment prefix (e.g., "digitalocean")
+                one_seg_prefix = parts[0]
+                if one_seg_prefix != two_seg_prefix:
+                    prefix_counts[one_seg_prefix].append(skill)
+
+        # Build pattern groups (require at least 2 skills per pattern)
+        pattern_groups = defaultdict(list)
+        used_skills = set()
+
+        # Prefer longer (more specific) prefixes
+        sorted_prefixes = sorted(prefix_counts.keys(), key=lambda x: (-len(x), x))
+
+        for prefix in sorted_prefixes:
+            matching_skills = prefix_counts[prefix]
+
+            # Only create a pattern group if we have 2+ skills and they're not already grouped
+            available_skills = [s for s in matching_skills if id(s) not in used_skills]
+
+            if len(available_skills) >= 2:
+                pattern_groups[prefix] = available_skills
+                used_skills.update(id(s) for s in available_skills)
+
+        # Add ungrouped skills to "" (Other) group
+        for skill in skills:
+            if id(skill) not in used_skills:
+                pattern_groups[""].append(skill)
+
+        return dict(pattern_groups)
+
+    def _get_pattern_icon(self, prefix: str) -> str:
+        """Get icon for a pattern prefix.
+
+        Args:
+            prefix: Pattern prefix (e.g., "digitalocean", "vercel")
+
+        Returns:
+            Emoji icon for the pattern
+        """
+        pattern_icons = {
+            "digitalocean": "🌊",
+            "aws": "☁️",
+            "github": "🐙",
+            "google": "🔍",
+            "vercel": "▲",
+            "netlify": "🦋",
+            "universal-testing": "🧪",
+            "universal-debugging": "🐛",
+            "universal-security": "🔒",
+            "toolchains-python": "🐍",
+            "toolchains-typescript": "📘",
+            "toolchains-javascript": "📒",
+        }
+        return pattern_icons.get(prefix, "📦")
+
+    def _manage_skill_installation(self) -> None:
+        """Manage skill installation with category-based questionary checkbox selection."""
+        import questionary
+
+        # Get all skills
+        all_skills = self._get_all_skills_from_git()
+        if not all_skills:
+            self.console.print(
+                "[yellow]No skills available. Try syncing skills first.[/yellow]"
+            )
+            Prompt.ask("\nPress Enter to continue")
+            return
+
+        # Get deployed skills
+        deployed = self._get_deployed_skill_ids()
+
+        # Group by category
+        grouped = {}
+        for skill in all_skills:
+            # Try to get category from tags or use toolchain
+            category = None
+            tags = skill.get("tags", [])
+
+            # Look for category tag
+            for tag in tags:
+                if tag in [
+                    "universal",
+                    "python",
+                    "typescript",
+                    "javascript",
+                    "go",
+                    "rust",
+                ]:
+                    category = tag
+                    break
+
+            # Fallback to toolchain or universal
+            if not category:
+                category = skill.get("toolchain", "universal")
+
+            if category not in grouped:
+                grouped[category] = []
+            grouped[category].append(skill)
+
+        # Category icons
+        icons = {
+            "universal": "🌐",
+            "python": "🐍",
+            "typescript": "📘",
+            "javascript": "📒",
+            "go": "🔷",
+            "rust": "⚙️",
+        }
+
+        # Sort categories: universal first, then alphabetically
+        categories = sorted(grouped.keys(), key=lambda x: (x != "universal", x))
+
+        while True:
+            # Show category selection first
+            self.console.clear()
+            self._display_header()
+            self.console.print("\n[bold cyan]Skills Management[/bold cyan]")
+            self.console.print(
+                f"[dim]{len(all_skills)} skills available, {len(deployed)} installed[/dim]\n"
+            )
+
+            cat_choices = [
+                Choice(
+                    title=f"{icons.get(cat, '📦')} {cat.title()} ({len(grouped[cat])} skills)",
+                    value=cat,
+                )
+                for cat in categories
+            ]
+            cat_choices.append(Choice(title="← Back to main menu", value="back"))
+
+            selected_cat = questionary.select(
+                "Select a category:", choices=cat_choices, style=self.QUESTIONARY_STYLE
+            ).ask()
+
+            if selected_cat is None or selected_cat == "back":
+                return
+
+            # Show skills in category with checkbox selection
+            category_skills = grouped[selected_cat]
+
+            # Detect pattern groups within category
+            pattern_groups = self._detect_skill_patterns(category_skills)
+
+            # Build choices with pattern grouping and installation status
+            skill_choices = []
+
+            # Track which skills belong to which group for expansion later
+            group_to_skills = {}
+
+            # Sort pattern groups: "" (Other) last, rest alphabetically
+            sorted_patterns = sorted(pattern_groups.keys(), key=lambda x: (x == "", x))
+
+            for pattern in sorted_patterns:
+                pattern_skills = pattern_groups[pattern]
+
+                # Skip empty groups
+                if not pattern_skills:
+                    continue
+
+                # Collect skill IDs in this group
+                skill_ids_in_group = []
+                for skill in pattern_skills:
+                    skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                    skill_ids_in_group.append(skill_id)
+
+                # Check if all skills in group are installed
+                all_installed = all(
+                    skill.get(
+                        "deployment_name", skill.get("name", skill.get("skill_id"))
+                    )
+                    in deployed
+                    or skill.get("name", skill.get("skill_id")) in deployed
+                    for skill in pattern_skills
+                )
+
+                # Add pattern group header as selectable choice
+                if pattern:
+                    # Named pattern group
+                    pattern_icon = self._get_pattern_icon(pattern)
+                    skill_count = len(pattern_skills)
+                    group_key = f"__group__:{pattern}"
+                    group_to_skills[group_key] = skill_ids_in_group
+
+                    skill_choices.append(
+                        Choice(
+                            title=f"{pattern_icon} {pattern} ({skill_count} skills) [Select All]",
+                            value=group_key,
+                            checked=all_installed,
+                        )
+                    )
+                elif pattern_skills:
+                    # "Other" group - only show if there are skills
+                    group_key = "__group__:Other"
+                    group_to_skills[group_key] = skill_ids_in_group
+
+                    skill_choices.append(
+                        Choice(
+                            title=f"📦 Other ({len(pattern_skills)} skills) [Select All]",
+                            value=group_key,
+                            checked=all_installed,
+                        )
+                    )
+
+                # Add skills in this pattern group
+                for skill in sorted(pattern_skills, key=lambda x: x.get("name", "")):
+                    skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                    deploy_name = skill.get("deployment_name", skill_id)
+                    description = skill.get("description", "")[:50]
+
+                    # Check if installed
+                    is_installed = deploy_name in deployed or skill_id in deployed
+
+                    # Add indentation for pattern-grouped skills (all skills are indented)
+                    skill_choices.append(
+                        Choice(
+                            title=f"    {skill_id} - {description}",
+                            value=skill_id,
+                            checked=is_installed,
+                        )
+                    )
+
+                # Add spacing between pattern groups (not after last group)
+                if pattern != sorted_patterns[-1]:
+                    skill_choices.append(Separator())
+
+            self.console.clear()
+            self._display_header()
+            self.console.print(
+                f"\n{icons.get(selected_cat, '📦')} [bold]{selected_cat.title()}[/bold]"
+            )
+            self.console.print(
+                "[dim]Use spacebar to toggle individual skills or entire groups, enter to confirm[/dim]\n"
+            )
+
+            selected = questionary.checkbox(
+                "Select skills to install:",
+                choices=skill_choices,
+                style=self.QUESTIONARY_STYLE,
+            ).ask()
+
+            if selected is None:
+                continue  # User cancelled, go back to category selection
+
+            # Process group selections - expand to individual skills
+            selected_set = set()
+            for item in selected:
+                if item.startswith("__group__:"):
+                    # Expand group selection to all skills in that group
+                    selected_set.update(group_to_skills[item])
+                else:
+                    # Individual skill selection
+                    selected_set.add(item)
+
+            current_in_cat = set()
+
+            # Find currently installed skills in this category
+            for skill in category_skills:
+                skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                deploy_name = skill.get("deployment_name", skill_id)
+                if deploy_name in deployed or skill_id in deployed:
+                    current_in_cat.add(skill_id)
+
+            # Install newly selected
+            to_install = selected_set - current_in_cat
+            for skill_id in to_install:
+                skill = next(
+                    (
+                        s
+                        for s in category_skills
+                        if s.get("name") == skill_id or s.get("skill_id") == skill_id
+                    ),
+                    None,
+                )
+                if skill:
+                    self._install_skill_from_dict(skill)
+                    self.console.print(f"[green]✓ Installed {skill_id}[/green]")
+
+            # Uninstall deselected
+            to_uninstall = current_in_cat - selected_set
+            for skill_id in to_uninstall:
+                # Find the skill to get deployment_name
+                skill = next(
+                    (
+                        s
+                        for s in category_skills
+                        if s.get("name") == skill_id or s.get("skill_id") == skill_id
+                    ),
+                    None,
+                )
+                if skill:
+                    deploy_name = skill.get("deployment_name", skill_id)
+                    # Use the name that's actually in deployed set
+                    name_to_uninstall = (
+                        deploy_name if deploy_name in deployed else skill_id
+                    )
+                    self._uninstall_skill_by_name(name_to_uninstall)
+                    self.console.print(f"[yellow]✗ Uninstalled {skill_id}[/yellow]")
+
+            # Update deployed set for next iteration
+            deployed = self._get_deployed_skill_ids()
+
+            # Show completion message
+            if to_install or to_uninstall:
+                Prompt.ask("\nPress Enter to continue")
+
+    def _get_all_skills_from_git(self) -> list:
+        """Get all skills from Git-based skill manager.
+
+        Returns:
+            List of skill dicts with full metadata from GitSkillSourceManager.
+        """
+        from ...config.skill_sources import SkillSourceConfiguration
+        from ...services.skills.git_skill_source_manager import GitSkillSourceManager
+
+        try:
+            config = SkillSourceConfiguration()
+            manager = GitSkillSourceManager(config)
+            return manager.get_all_skills()
+        except Exception as e:
+            self.console.print(
+                f"[yellow]Warning: Could not load Git skills: {e}[/yellow]"
+            )
+            return []
+
+    def _display_skills_table_grouped(self) -> None:
+        """Display skills in a table grouped by category, like agents."""
+        from rich import box
+        from rich.table import Table
+
+        # Get all skills from Git manager
+        all_skills = self._get_all_skills_from_git()
+        deployed_ids = self._get_deployed_skill_ids()
+
+        if not all_skills:
+            self.console.print(
+                "[yellow]No skills available. Try syncing skills first.[/yellow]"
+            )
+            return
+
+        # Group skills by category/toolchain
+        grouped = {}
+        for skill in all_skills:
+            # Try to get category from tags or use toolchain
+            category = None
+            tags = skill.get("tags", [])
+
+            # Look for category tag
+            for tag in tags:
+                if tag in [
+                    "universal",
+                    "python",
+                    "typescript",
+                    "javascript",
+                    "go",
+                    "rust",
+                ]:
+                    category = tag
+                    break
+
+            # Fallback to toolchain or universal
+            if not category:
+                category = skill.get("toolchain", "universal")
+
+            if category not in grouped:
+                grouped[category] = []
+            grouped[category].append(skill)
+
+        # Sort categories: universal first, then alphabetically
+        categories = sorted(grouped.keys(), key=lambda x: (x != "universal", x))
+
+        # Track global skill number across all categories
+        skill_counter = 0
+
+        for category in categories:
+            category_skills = grouped[category]
+
+            # Category header with icon
+            icons = {
+                "universal": "🌐",
+                "python": "🐍",
+                "typescript": "📘",
+                "javascript": "📒",
+                "go": "🔷",
+                "rust": "⚙️",
+            }
+            icon = icons.get(category, "📦")
+            self.console.print(
+                f"\n{icon} [bold cyan]{category.title()}[/bold cyan] ({len(category_skills)} skills)"
+            )
+
+            # Create table for this category
+            table = Table(show_header=True, header_style="bold", box=box.SIMPLE)
+            table.add_column("#", style="dim", width=4)
+            table.add_column("Skill ID", style="cyan", width=35)
+            table.add_column("Description", style="white", width=45)
+            table.add_column("Status", style="green", width=12)
+
+            for skill in sorted(category_skills, key=lambda x: x.get("name", "")):
+                skill_counter += 1
+                skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                # Use deployment_name for matching if available
+                deploy_name = skill.get("deployment_name", skill_id)
+                description = skill.get("description", "")[:45]
+
+                # Check if installed - handle both deployment_name and skill_id
+                is_installed = deploy_name in deployed_ids or skill_id in deployed_ids
+                status = "[green]✓ Installed[/green]" if is_installed else "Available"
+
+                table.add_row(str(skill_counter), skill_id, description, status)
+
+            self.console.print(table)
+
+        # Summary
+        total = len(all_skills)
+        installed = sum(
+            1
+            for s in all_skills
+            if s.get("deployment_name", s.get("name", "")) in deployed_ids
+            or s.get("name", "") in deployed_ids
+        )
+        self.console.print(
+            f"\n[dim]Showing {total} skills ({installed} installed)[/dim]"
+        )
+
+    def _get_deployed_skill_ids(self) -> set:
+        """Get set of deployed skill IDs from .claude/skills/ directory.
+
+        Returns:
+            Set of skill directory names and common variations for matching.
+        """
+        from pathlib import Path
+
+        skills_dir = Path.cwd() / ".claude" / "skills"
+        if not skills_dir.exists():
+            return set()
+
+        # Each deployed skill is a directory in .claude/skills/
+        deployed_ids = set()
+        for skill_dir in skills_dir.iterdir():
+            if skill_dir.is_dir() and not skill_dir.name.startswith("."):
+                # Add both the directory name and common variations
+                deployed_ids.add(skill_dir.name)
+                # Also add without prefix for matching (e.g., universal-testing -> testing)
+                if skill_dir.name.startswith("universal-"):
+                    deployed_ids.add(skill_dir.name.replace("universal-", "", 1))
+
+        return deployed_ids
+
+    def _install_skill(self, skill) -> None:
+        """Install a skill to .claude/skills/ directory."""
+        import shutil
+        from pathlib import Path
+
+        # Target directory
+        target_dir = Path.cwd() / ".claude" / "skills" / skill.skill_id
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy skill file(s)
+        if skill.path.is_file():
+            # Single file skill - copy to skill.md in target directory
+            shutil.copy2(skill.path, target_dir / "skill.md")
+        elif skill.path.is_dir():
+            # Directory-based skill - copy all contents
+            for item in skill.path.iterdir():
+                if item.is_file():
+                    shutil.copy2(item, target_dir / item.name)
+                elif item.is_dir():
+                    shutil.copytree(item, target_dir / item.name, dirs_exist_ok=True)
+
+    def _uninstall_skill(self, skill) -> None:
+        """Uninstall a skill from .claude/skills/ directory."""
+        import shutil
+        from pathlib import Path
+
+        target_dir = Path.cwd() / ".claude" / "skills" / skill.skill_id
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+
+    def _install_skill_from_dict(self, skill_dict: dict) -> None:
+        """Install a skill from Git skill dict to .claude/skills/ directory.
+
+        Args:
+            skill_dict: Skill metadata dict from GitSkillSourceManager.get_all_skills()
+        """
+        from pathlib import Path
+
+        skill_id = skill_dict.get("name", skill_dict.get("skill_id", "unknown"))
+        content = skill_dict.get("content", "")
+
+        if not content:
+            self.console.print(
+                f"[yellow]Warning: Skill '{skill_id}' has no content[/yellow]"
+            )
+            return
+
+        # Target directory using deployment_name if available
+        deploy_name = skill_dict.get("deployment_name", skill_id)
+        target_dir = Path.cwd() / ".claude" / "skills" / deploy_name
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Write skill content to skill.md
+        skill_file = target_dir / "skill.md"
+        skill_file.write_text(content, encoding="utf-8")
+
+    def _uninstall_skill_by_name(self, skill_name: str) -> None:
+        """Uninstall a skill by name from .claude/skills/ directory.
+
+        Args:
+            skill_name: Name of skill directory to remove
+        """
+        import shutil
+        from pathlib import Path
+
+        target_dir = Path.cwd() / ".claude" / "skills" / skill_name
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+
     def _display_behavior_files(self) -> None:
         """Display current behavior files."""
         self.behavior_manager.display_behavior_files()
@@ -908,14 +1569,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
+                    Path.home() / ".claude-mpm" / "cache" / "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(
                     {
@@ -969,21 +1630,123 @@ class ConfigureCommand(BaseCommand):
         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 _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
 
-        agents_table = Table(show_header=True, header_style="bold white")
-        agents_table.add_column("#", style="dim", width=4, no_wrap=True)
+        # 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 = {
+            "#": 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 cyan")
         agents_table.add_column(
-            "Agent ID", style="white", width=35, no_wrap=True, overflow="ellipsis"
+            "#", style="bright_black", width=widths["#"], no_wrap=True
         )
         agents_table.add_column(
-            "Name", style="white", width=25, no_wrap=True, overflow="ellipsis"
+            "Agent ID",
+            style="bright_black",
+            width=widths["Agent ID"],
+            no_wrap=True,
+            overflow="ellipsis",
         )
-        agents_table.add_column("Source", style="bright_yellow", width=20, no_wrap=True)
-        agents_table.add_column("Status", style="white", width=12, no_wrap=True)
-
+        agents_table.add_column(
+            "Name",
+            style="bright_cyan",
+            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="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")
@@ -1011,23 +1774,83 @@ 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
+            # Use agent_id (technical ID like "python-engineer") not display name
+            agent_id = getattr(agent, "agent_id", agent.name)
+            is_installed = agent_id 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: Show agent_id (technical ID) in first column, not display name
+            agent_id_display = getattr(agent, "agent_id", 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)
-        self.console.print(f"\n[dim]Total: {len(agents)} agents available[/dim]")
+
+        # 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)
+        # Use agent_id (technical ID) for comparison, not display name
+        installed_count = sum(
+            1 for a in agents if getattr(a, "agent_id", 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]"
+        )
 
     def _manage_sources(self) -> None:
         """Interactive source management."""
@@ -1041,8 +1864,480 @@ 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": getattr(a, "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
+        # Use agent_id (technical ID) for comparison, not display name
+        deployed_full_paths = set()
+        for agent in agents:
+            agent_id = getattr(agent, "agent_id", agent.name)
+            agent_leaf_name = agent_id.split("/")[-1]
+            if agent_leaf_name in deployed_ids:
+                # Store agent_id for selection tracking (not display name)
+                deployed_full_paths.add(agent_id)
+
+        # 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:
+            # Use agent_id (technical ID) for comparison, not display name
+            agent_id = getattr(agent, "agent_id", agent.name)
+            if agent_id 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_id] = 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
+                # Use agent_id for selection tracking, not display name
+                selected_count = sum(
+                    1
+                    for agent in agents_in_collection
+                    if getattr(agent, "agent_id", 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:
+                    deselect_value = f"__DESELECT_ALL_{collection_id}__"
+                    choices.append(
+                        Choice(
+                            f"  [Deselect all from {collection_id}]",  # nosec B608
+                            value=deselect_value,
+                            checked=False,
+                        )
+                    )
+                else:
+                    select_value = f"__SELECT_ALL_{collection_id}__"
+                    choices.append(
+                        Choice(
+                            f"  [Select all from {collection_id}]",  # nosec B608
+                            value=select_value,
+                            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:
+                        # Use agent_id (technical ID) for all tracking/selection
+                        agent_id = getattr(agent, "agent_id", agent.name)
+                        agent_leaf_name = agent_id.split("/")[-1]
+                        raw_display_name = getattr(
+                            agent, "display_name", agent_leaf_name
+                        )
+                        display_name = self._format_display_name(raw_display_name)
+
+                        # Check if agent is required (cannot be unchecked)
+                        required_agents = set(self.unified_config.agents.required)
+                        is_required = (
+                            agent_leaf_name in required_agents
+                            or agent_id in required_agents
+                        )
+
+                        # Format choice text with [Required] indicator
+                        if is_required:
+                            choice_text = f"    {display_name} [Required]"
+                        else:
+                            choice_text = f"    {display_name}"
+
+                        # Required agents are always selected
+                        is_selected = is_required or agent_id in current_selection
+
+                        # Add to current selection if required
+                        if is_required:
+                            current_selection.add(agent_id)
+
+                        choices.append(
+                            Choice(
+                                title=choice_text,
+                                value=agent_id,  # Use agent_id for value
+                                checked=is_selected,
+                                disabled=is_required,  # Disable checkbox for required agents
+                            )
+                        )
+
+            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][Required] = Core agents (always installed)[/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]:
+                            agent_id = getattr(agent, "agent_id", agent.name)
+                            current_selection.add(agent_id)
+                    elif control.startswith("__DESELECT_ALL_"):
+                        collection_id = control.replace("__DESELECT_ALL_", "").replace(
+                            "__", ""
+                        )
+                        # Remove all agents from this collection
+                        for agent in collections[collection_id]:
+                            agent_id = getattr(agent, "agent_id", agent.name)
+                            current_selection.discard(agent_id)
+                    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]:
+                            agent_id = getattr(agent, "agent_id", agent.name)
+                            if any(
+                                agent_id == rec_id
+                                or agent_id.split("/")[-1] == rec_id.split("/")[-1]
+                                for rec_id in recommended_agent_ids
+                            ):
+                                current_selection.add(agent_id)
+                    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]:
+                            agent_id = getattr(agent, "agent_id", agent.name)
+                            if any(
+                                agent_id == rec_id
+                                or agent_id.split("/")[-1] == rec_id.split("/")[-1]
+                                for rec_id in recommended_agent_ids
+                            ):
+                                current_selection.discard(agent_id)
+
+                # Loop back to re-display with updated selections
+                continue
+
+            # No controls selected - use the individual selections as final
+            final_selection = set(selected_values)
+
+            # Ensure required agents are always in the final selection
+            required_agents = set(self.unified_config.agents.required)
+            for agent in agents:
+                agent_id = getattr(agent, "agent_id", agent.name)
+                agent_leaf_name = agent_id.split("/")[-1]
+                if agent_leaf_name in required_agents or agent_id in required_agents:
+                    final_selection.add(agent_id)
+
+            break
+
+        # Determine changes
+        to_deploy = final_selection - deployed_full_paths
+        to_remove = deployed_full_paths - final_selection
+
+        # Prevent removal of required agents
+        required_agents = set(self.unified_config.agents.required)
+        to_remove_filtered = set()
+        for agent_id in to_remove:
+            agent_leaf_name = agent_id.split("/")[-1]
+            if (
+                agent_leaf_name not in required_agents
+                and agent_id not in required_agents
+            ):
+                to_remove_filtered.add(agent_id)
+            else:
+                self.console.print(
+                    f"[yellow]⚠ Cannot remove required agent: {agent_id}[/yellow]"
+                )
+        to_remove = to_remove_filtered
+
+        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")
@@ -1058,7 +2353,7 @@ class ConfigureCommand(BaseCommand):
         all_agents = filter_base_agents(
             [
                 {
-                    "agent_id": a.name,
+                    "agent_id": getattr(a, "agent_id", a.name),
                     "name": a.name,
                     "description": a.description,
                     "deployed": getattr(a, "is_deployed", False),
@@ -1067,7 +2362,8 @@ class ConfigureCommand(BaseCommand):
             ]
         )
 
-        # Get deployed agent IDs
+        # 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:
@@ -1075,68 +2371,296 @@ class ConfigureCommand(BaseCommand):
             Prompt.ask("\nPress Enter to continue")
             return
 
+        # Build mapping: leaf name -> full path for deployed agents
+        # This allows comparing deployed_ids (leaf names) with agent.agent_id (full paths)
+        deployed_full_paths = set()
+        for agent in agents:
+            # FIX: Use agent_id (technical ID) instead of display name
+            agent_id = getattr(agent, "agent_id", agent.name)
+            agent_leaf_name = agent_id.split("/")[-1]
+            if agent_leaf_name in deployed_ids:
+                deployed_full_paths.add(agent_id)
+
+        # Track current selection state (starts with deployed full paths, updated after each iteration)
+        current_selection = deployed_full_paths.copy()
+
         # Loop to allow adjusting selection
         while True:
-            # Build checkbox choices with pre-selection
-            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 if deployed
-                    # Extract leaf name from full path for comparison with deployed_ids
-                    agent_leaf_name = agent.name.split("/")[-1]
-                    is_deployed = agent_leaf_name in deployed_ids
-
-                    # Simple format: "agent/path - Display Name"
-                    # Checkbox state (checked/unchecked) indicates installed status
-                    choice_text = f"{agent.name}"
-                    if display_name and display_name != agent.name:
-                        choice_text += f" - {display_name}"
-
-                    # Create choice with checked=True for deployed agents
-                    # Note: questionary's default param is for single-select only
-                    # For multi-select, must use checked=True on Choice objects
-                    choice = questionary.Choice(
-                        title=choice_text, value=agent.name, checked=is_deployed
-                    )
+                # FIX: Use agent_id (technical ID) for comparison
+                agent_id = getattr(agent, "agent_id", agent.name)
+                if agent_id 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", "")
+                        # 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)
-                    agent_map[agent.name] = agent
+                    collections[collection_id].append(agent)
+                    agent_map[agent_id] = agent  # FIX: Use agent_id as key
 
-            # 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]")
+            # STEP 1: Collection-level selection
+            self.console.print("\n[bold cyan]Select Agent Collections[/bold cyan]")
             self.console.print(
-                "[dim]Use arrow keys to navigate, space to toggle, "
-                "Enter to apply changes[/dim]\n"
+                "[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]For partial deployment, use 'Fine-tune individual agents'[/dim]\n"
             )
 
-            # Pre-selection via checked=True on Choice objects
-            # (questionary's default param is for single-select only)
-            selected_agent_ids = questionary.checkbox(
-                "Agents:", choices=agent_choices, style=self.QUESTIONARY_STYLE
-            ).ask()
+            collection_choices = []
+            for collection_id in sorted(collections.keys()):
+                agents_in_collection = collections[collection_id]
 
-            # Handle Esc
-            if selected_agent_ids is None:
-                self.console.print("[yellow]No changes made[/yellow]")
+                # Check if ANY agent in this collection is currently deployed
+                # This reflects actual deployment state, not just selection
+                # FIX: Use agent_id for comparison with current_selection
+                any_deployed = any(
+                    getattr(agent, "agent_id", agent.name) in current_selection
+                    for agent in agents_in_collection
+                )
+
+                # Count deployed agents for display
+                # FIX: Use agent_id for comparison with current_selection
+                deployed_count = sum(
+                    1
+                    for agent in agents_in_collection
+                    if getattr(agent, "agent_id", 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
+            questionary.prompts.common.INDICATOR_SELECTED = "[✓]"
+            questionary.prompts.common.INDICATOR_UNSELECTED = "[ ]"
+
+            try:
+                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:
+                import sys
+
+                self.logger.error(f"Questionary checkbox failed: {e}", exc_info=True)
+                self.console.print(
+                    "[red]Error: Could not display interactive menu[/red]"
+                )
+                self.console.print(f"[dim]Reason: {e}[/dim]")
+                if not sys.stdin.isatty():
+                    self.console.print("[dim]Interactive terminal required. Use:[/dim]")
+                    self.console.print(
+                        "[dim]  --list-agents to see available agents[/dim]"
+                    )
+                    self.console.print(
+                        "[dim]  --enable-agent/--disable-agent for scripting[/dim]"
+                    )
+                else:
+                    self.console.print(
+                        "[dim]This might be a terminal compatibility issue.[/dim]"
+                    )
+                Prompt.ask("\nPress Enter to continue")
+                return
+
+            # Handle cancellation
+            if selected_collections is None:
+                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
 
-            # Convert to sets for comparison
-            selected_set = set(selected_agent_ids)
-            deployed_set = deployed_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
+                    # FIX: Use agent_id for sorting, comparison, and values
+                    for agent in sorted(
+                        agents_in_collection,
+                        key=lambda a: getattr(a, "agent_id", a.name),
+                    ):
+                        agent_id = getattr(agent, "agent_id", agent.name)
+                        raw_display_name = getattr(agent, "display_name", agent.name)
+                        display_name = self._format_display_name(raw_display_name)
+                        is_selected = agent_id in deployed_full_paths
+
+                        choice_text = f"{agent_id}"
+                        if display_name and display_name != agent_id:
+                            choice_text += f" - {display_name}"
+
+                        agent_choices.append(
+                            Choice(
+                                title=choice_text, value=agent_id, 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]:
+                        # FIX: Use agent_id for selection tracking
+                        final_selections.add(getattr(agent, "agent_id", 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
+
+            # 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
 
-            # Determine actions
-            to_deploy = selected_set - deployed_set  # Selected but not deployed
-            to_remove = deployed_set - selected_set  # Deployed but not selected
+                            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("[yellow]No changes made[/yellow]")
+                self.console.print(
+                    "[yellow]No changes needed - all selected agents are already installed[/yellow]"
+                )
                 Prompt.ask("\nPress Enter to continue")
                 return
 
@@ -1168,7 +2692,7 @@ class ConfigureCommand(BaseCommand):
                 Prompt.ask("\nPress Enter to continue")
                 return
             if action == "adjust":
-                # Loop back to agent selection
+                # current_selection is already updated, loop will use it
                 continue
 
             # Execute changes
@@ -1191,14 +2715,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]:
@@ -1219,11 +2751,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
@@ -1347,6 +2880,170 @@ 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:  # nosec B110 - Suppress broad except for failed safety check
+            # Silent failure on safety check - non-critical feature
+            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:
@@ -1372,8 +3069,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
 
@@ -1421,7 +3118,8 @@ class ConfigureCommand(BaseCommand):
 
         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)
+            raw_display_name = getattr(agent, "display_name", agent.name)
+            display_name = self._format_display_name(raw_display_name)
             self.console.print(f"  {idx}. {agent.name} - {display_name}")
 
         selection = Prompt.ask("\nEnter agent number to remove (or 'c' to cancel)")
@@ -1484,7 +3182,8 @@ class ConfigureCommand(BaseCommand):
 
         self.console.print(f"\n[bold]Available agents ({len(agents)}):[/bold]")
         for idx, agent in enumerate(agents, 1):
-            display_name = getattr(agent, "display_name", agent.name)
+            raw_display_name = getattr(agent, "display_name", agent.name)
+            display_name = self._format_display_name(raw_display_name)
             self.console.print(f"  {idx}. {agent.name} - {display_name}")
 
         selection = Prompt.ask("\nEnter agent number to view (or 'c' to cancel)")
@@ -1501,7 +3200,12 @@ class ConfigureCommand(BaseCommand):
 
                 # Basic info
                 self.console.print(f"[bold]ID:[/bold] {agent.name}")
-                display_name = getattr(agent, "display_name", "N/A")
+                raw_display_name = getattr(agent, "display_name", "N/A")
+                display_name = (
+                    self._format_display_name(raw_display_name)
+                    if raw_display_name != "N/A"
+                    else "N/A"
+                )
                 self.console.print(f"[bold]Name:[/bold] {display_name}")
                 self.console.print(f"[bold]Description:[/bold] {agent.description}")