claude-mpm 5.4.74__py3-none-any.whl → 5.4.81__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -26,6 +26,7 @@ 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
@@ -79,6 +80,7 @@ class ConfigureCommand(BaseCommand):
         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."""
@@ -162,6 +164,18 @@ class ConfigureCommand(BaseCommand):
             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
@@ -656,25 +670,22 @@ class ConfigureCommand(BaseCommand):
         self.behavior_manager.manage_behaviors()
 
     def _manage_skills(self) -> None:
-        """Skills management interface with table display."""
+        """Skills management interface with questionary checkbox selection."""
         from ...cli.interactive.skills_wizard import SkillsWizard
-        from ...skills.registry import get_registry
         from ...skills.skill_manager import get_manager
 
         wizard = SkillsWizard()
         manager = get_manager()
-        registry = get_registry()
 
         while True:
             self.console.clear()
             self._display_header()
 
-            # Display skills table
-            self._display_skills_table(registry)
+            self.console.print("\n[bold]Skills Management[/bold]")
 
             # Show action options
             self.console.print("\n[bold]Actions:[/bold]")
-            self.console.print("  [1] Toggle skill installation")
+            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")
@@ -684,57 +695,8 @@ class ConfigureCommand(BaseCommand):
             choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
             if choice == "1":
-                # Toggle skill installation
-                self.console.clear()
-                self._display_header()
-                self._display_skills_table(registry)
-
-                skill_num = Prompt.ask(
-                    "\n[bold blue]Enter skill number to toggle (or 'b' to go back)[/bold blue]",
-                    default="b",
-                )
-
-                if skill_num == "b":
-                    continue
-
-                try:
-                    skill_idx = int(skill_num) - 1
-                    all_skills = self._get_all_skills_sorted(registry)
-
-                    if 0 <= skill_idx < len(all_skills):
-                        skill = all_skills[skill_idx]
-                        deployed_ids = self._get_deployed_skill_ids()
-
-                        if skill.skill_id in deployed_ids:
-                            # Uninstall
-                            confirm = Confirm.ask(
-                                f"\n[yellow]Uninstall skill '{skill.name}'?[/yellow]",
-                                default=False,
-                            )
-                            if confirm:
-                                self._uninstall_skill(skill)
-                                self.console.print(
-                                    f"\n[green]✓ Skill '{skill.name}' uninstalled[/green]"
-                                )
-                        else:
-                            # Install
-                            confirm = Confirm.ask(
-                                f"\n[cyan]Install skill '{skill.name}'?[/cyan]",
-                                default=True,
-                            )
-                            if confirm:
-                                self._install_skill(skill)
-                                self.console.print(
-                                    f"\n[green]✓ Skill '{skill.name}' installed[/green]"
-                                )
-                    else:
-                        self.console.print("[red]Invalid skill number[/red]")
-                except ValueError:
-                    self.console.print(
-                        "[red]Invalid input. Please enter a number.[/red]"
-                    )
-
-                Prompt.ask("\nPress Enter to continue")
+                # Install/Uninstall skills with category-based selection
+                self._manage_skill_installation()
 
             elif choice == "2":
                 # Configure skills interactively
@@ -857,72 +819,461 @@ class ConfigureCommand(BaseCommand):
                 self.console.print("[red]Invalid choice. Please try again.[/red]")
                 Prompt.ask("\nPress Enter to continue")
 
-    def _display_skills_table(self, registry) -> None:
-        """Display skills in a table format like agents."""
-        from rich import box
-        from rich.table import Table
+    def _detect_skill_patterns(self, skills: list[dict]) -> dict[str, list[dict]]:
+        """Group skills by detected common prefixes.
 
-        # Get all skills and deployed skill IDs
-        all_skills = self._get_all_skills_sorted(registry)
-        deployed_ids = self._get_deployed_skill_ids()
+        Args:
+            skills: List of skill dictionaries
 
-        # Create table with same styling as agents table
-        table = Table(show_header=True, header_style="bold cyan", box=box.ROUNDED)
-        table.add_column("#", style="bright_black", width=6)
-        table.add_column("Skill ID", style="bright_black", overflow="ellipsis")
-        table.add_column("Name", style="bright_cyan", overflow="ellipsis")
-        table.add_column("Source", style="bright_yellow")
-        table.add_column("Status", style="bright_black")
-
-        # Populate table
-        for i, skill in enumerate(all_skills, 1):
-            # Determine status
-            if skill.skill_id in deployed_ids:
-                status = "[green]Installed[/green]"
-            else:
-                status = "Available"
+        Returns:
+            Dict mapping pattern prefix to list of skills.
+            Skills without pattern match go under "" (empty string) key.
+        """
+        from collections import defaultdict
 
-            # Determine source label
-            if skill.source == "bundled":
-                source = "MPM Skills"
-            elif skill.source == "user":
-                source = "User Skills"
-            elif skill.source == "project":
-                source = "Project Skills"
-            else:
-                source = skill.source.title()
+        # Count prefix occurrences (try 1-segment and 2-segment prefixes)
+        prefix_counts = defaultdict(list)
 
-            # Get display name (fallback to skill_id with formatting)
-            name = skill.name or skill.skill_id.replace("-", " ").title()
+        for skill in skills:
+            skill_id = skill.get("name", skill.get("skill_id", ""))
 
-            table.add_row(str(i), skill.skill_id, name, source, status)
+            # Try to extract prefixes (split by hyphen)
+            parts = skill_id.split("-")
 
-        self.console.print(table)
+            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)
 
-        # Show summary
-        installed_count = len([s for s in all_skills if s.skill_id in deployed_ids])
-        self.console.print(
-            f"\nShowing {len(all_skills)} skills ({installed_count} installed)"
-        )
+                # 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()
 
-    def _get_all_skills_sorted(self, registry):
-        """Get all skills from registry, sorted by source and name."""
-        # Get skills from all sources
-        bundled = registry.list_skills(source="bundled")
-        user = registry.list_skills(source="user")
-        project = registry.list_skills(source="project")
+            if selected is None:
+                continue  # User cancelled, go back to category selection
 
-        # Combine and sort: bundled first, then user, then project
-        # Within each group, sort by name
-        all_skills = []
-        all_skills.extend(sorted(bundled, key=lambda s: s.name.lower()))
-        all_skills.extend(sorted(user, key=lambda s: s.name.lower()))
-        all_skills.extend(sorted(project, key=lambda s: s.name.lower()))
+            # 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]")
 
-        return all_skills
+            # 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."""
+        """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"
@@ -933,7 +1284,11 @@ class ConfigureCommand(BaseCommand):
         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
 
@@ -967,6 +1322,45 @@ class ConfigureCommand(BaseCommand):
         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()
@@ -1682,18 +2076,32 @@ class ConfigureCommand(BaseCommand):
                         )
                         display_name = self._format_display_name(raw_display_name)
 
-                        # Check if agent is deployed (exists in .claude/agents/)
+                        # 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}"
 
-                        # Format choice text (no asterisk needed)
-                        choice_text = f"    {display_name}"
+                        # Required agents are always selected
+                        is_selected = is_required or agent_id in current_selection
 
-                        is_selected = 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
                             )
                         )
 
@@ -1702,6 +2110,7 @@ class ConfigureCommand(BaseCommand):
             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"
             )
@@ -1788,12 +2197,37 @@ class ConfigureCommand(BaseCommand):
 
             # 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")