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

claude_mpm/cli/commands/skills.py

@@ -18,7 +18,7 @@ ARCHITECTURE:
 """
 
 import os
-import subprocess
+import subprocess  # nosec B404
 from typing import Optional
 
 from rich.console import Console
@@ -84,6 +84,7 @@ class SkillsManagementCommand(BaseCommand):
                 SkillsCommands.INFO.value: self._show_skill_info,
                 SkillsCommands.CONFIG.value: self._manage_config,
                 SkillsCommands.CONFIGURE.value: self._configure_skills,
+                SkillsCommands.SELECT.value: self._select_skills_interactive,
                 # GitHub deployment commands
                 SkillsCommands.DEPLOY_FROM_GITHUB.value: self._deploy_from_github,
                 SkillsCommands.LIST_AVAILABLE.value: self._list_available_github_skills,
@@ -504,7 +505,7 @@ class SkillsManagementCommand(BaseCommand):
                 # Open in editor
                 editor = os.environ.get("EDITOR", "nano")
                 try:
-                    subprocess.run([editor, str(config_path)], check=True)
+                    subprocess.run([editor, str(config_path)], check=True)  # nosec B603
                     console.print(
                         f"\n[green]Configuration saved to {config_path}[/green]\n"
                     )
@@ -537,7 +538,7 @@ class SkillsManagementCommand(BaseCommand):
             toolchain = getattr(args, "toolchain", None)
             categories = getattr(args, "categories", None)
             force = getattr(args, "force", False)
-            all_skills = getattr(args, "all", False)
+            deploy_all = getattr(args, "all", False)
 
             if collection:
                 console.print(
@@ -548,23 +549,30 @@ class SkillsManagementCommand(BaseCommand):
                     "\n[bold cyan]Deploying skills from default collection...[/bold cyan]\n"
                 )
 
-            # Auto-detect toolchain if not specified and not deploying all
-            if not toolchain and not all_skills:
-                console.print(
-                    "[yellow]No toolchain specified. Use --toolchain to filter by language,[/yellow]"
-                )
-                console.print(
-                    "[yellow]or --all to deploy all available skills.[/yellow]\n"
-                )
-
+            # Use selective deployment unless --all flag is provided
+            # Selective mode deploys only agent-referenced skills
+            # --all mode deploys all available skills from the collection
             result = self.skills_deployer.deploy_skills(
                 collection=collection,
                 toolchain=toolchain,
                 categories=categories,
                 force=force,
+                selective=not deploy_all,
             )
 
             # Display results
+            # Show selective mode summary
+            if result.get("selective_mode"):
+                total_available = result.get("total_available", 0)
+                deployed_count = result["deployed_count"]
+                console.print(
+                    f"[cyan]📌 Selective deployment: {deployed_count} agent-referenced skills "
+                    f"(out of {total_available} available)[/cyan]"
+                )
+                console.print(
+                    "[dim]Use 'claude-mpm skills configure' to manually select skills[/dim]\n"
+                )
+
             if result["deployed_count"] > 0:
                 console.print(
                     f"[green]✓ Deployed {result['deployed_count']} skill(s):[/green]"
@@ -587,6 +595,16 @@ class SkillsManagementCommand(BaseCommand):
                     console.print(f"  • {error}")
                 console.print()
 
+            # Show cleanup results
+            cleanup = result.get("cleanup", {})
+            if cleanup.get("removed_count", 0) > 0:
+                console.print(
+                    f"[yellow]🧹 Removed {cleanup['removed_count']} orphaned skill(s):[/yellow]"
+                )
+                for skill in cleanup.get("removed_skills", []):
+                    console.print(f"  • {skill}")
+                console.print()
+
             # Show restart instructions
             if result["restart_instructions"]:
                 console.print(
@@ -658,33 +676,91 @@ class SkillsManagementCommand(BaseCommand):
     def _check_deployed_skills(self, args) -> CommandResult:
         """Check currently deployed skills in ~/.claude/skills/."""
         try:
-            result = self.skills_deployer.check_deployed_skills()
+            # Get deployed skills
+            deployed_result = self.skills_deployer.check_deployed_skills()
+            deployed_names = {skill["name"] for skill in deployed_result["skills"]}
 
             console.print("\n[bold cyan]Claude Code Skills Status:[/bold cyan]\n")
-            console.print(f"[dim]Directory: {result['claude_skills_dir']}[/dim]\n")
+            console.print(
+                f"[dim]Directory: {deployed_result['claude_skills_dir']}[/dim]\n"
+            )
+
+            # Fetch available skills from GitHub to get full list
+            try:
+                available_result = self.skills_deployer.list_available_skills()
+                all_skills = available_result.get("skills", [])
+            except Exception as e:
+                console.print(
+                    f"[yellow]Warning: Could not fetch available skills: {e}[/yellow]\n"
+                )
+                all_skills = []
+
+            # Combine deployed and available skills
+            skill_map = {}
+
+            # Add available skills
+            for skill in all_skills:
+                skill_name = skill.get("name", "")
+                if skill_name:
+                    skill_map[skill_name] = {
+                        "name": skill.get("display_name")
+                        or skill_name.replace("-", " ").title(),
+                        "skill_id": skill_name,
+                        "source": "MPM Skills",
+                        "is_deployed": skill_name in deployed_names,
+                    }
 
-            if result["deployed_count"] == 0:
-                console.print("[yellow]No skills currently deployed.[/yellow]")
+            # Add any deployed skills not in available list (local/custom skills)
+            for skill in deployed_result["skills"]:
+                skill_name = skill["name"]
+                if skill_name not in skill_map:
+                    skill_map[skill_name] = {
+                        "name": skill_name.replace("-", " ").title(),
+                        "skill_id": skill_name,
+                        "source": "Local",
+                        "is_deployed": True,
+                    }
+
+            if not skill_map:
+                console.print("[yellow]No skills available.[/yellow]")
                 console.print(
                     "[dim]Use 'claude-mpm skills deploy-github' to deploy skills.[/dim]\n"
                 )
                 return CommandResult(success=True, exit_code=0)
 
-            console.print(
-                f"[green]{result['deployed_count']} skill(s) deployed:[/green]\n"
+            # Create table matching agent management format
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("#", style="bright_black", width=6, no_wrap=True)
+            table.add_column(
+                "Skill ID", style="bright_black", no_wrap=True, overflow="ellipsis"
             )
+            table.add_column(
+                "Name", style="bright_cyan", no_wrap=True, overflow="ellipsis"
+            )
+            table.add_column("Source", style="bright_yellow", no_wrap=True)
+            table.add_column("Status", style="bright_black", no_wrap=True)
 
-            # Create table for deployed skills
-            table = Table(show_header=True, header_style="bold cyan")
-            table.add_column("Skill Name", style="green")
-            table.add_column("Path", style="dim")
+            # Sort skills by name for consistent display
+            sorted_skills = sorted(skill_map.values(), key=lambda s: s["skill_id"])
 
-            for skill in sorted(result["skills"], key=lambda s: s["name"]):
-                table.add_row(skill["name"], skill["path"])
+            for idx, skill in enumerate(sorted_skills, 1):
+                status = (
+                    "[green]Installed[/green]" if skill["is_deployed"] else "Available"
+                )
+                table.add_row(
+                    str(idx), skill["skill_id"], skill["name"], skill["source"], status
+                )
 
             console.print(table)
             console.print()
 
+            # Show summary
+            deployed_count = sum(1 for s in skill_map.values() if s["is_deployed"])
+            console.print(
+                f"[dim]Showing {len(skill_map)} skills ({deployed_count} installed, "
+                f"{len(skill_map) - deployed_count} available)[/dim]\n"
+            )
+
             return CommandResult(success=True, exit_code=0)
 
         except Exception as e:
@@ -953,23 +1029,37 @@ class SkillsManagementCommand(BaseCommand):
             console.print(f"[red]Unexpected error: {e}[/red]")
 
     def _configure_skills(self, args) -> CommandResult:
-        """Interactive skills configuration with checkbox selection.
+        """Interactive skills configuration using configuration.yaml.
 
         Provides checkbox-based selection interface matching agents configure UX:
-        - Status column showing Installed/Available
-        - Pre-selection for installed skills
-        - Apply/Adjust/Cancel menu
-        - While loop for adjustment
-        - Simplified labels (checkbox state only)
-
-        This is Option 3 (Hybrid approach): Separate command for interactive mode
-        while keeping deploy-github for CLI automation.
+        - Shows current mode (user_defined vs agent_referenced)
+        - If agent mode: shows agent-scanned skills
+        - Allows switching to user_defined mode and selecting skills
+        - Can reset to agent mode (clears user_defined)
+        - Saves selections to configuration.yaml
+
+        Configuration structure:
+        ```yaml
+        skills:
+          agent_referenced:  # Auto-populated from agent scan (read-only)
+            - systematic-debugging
+            - typescript-core
+          user_defined:      # User override - if set, ONLY these are deployed
+            []               # Empty = use agent_referenced
+        ```
         """
         try:
+            from pathlib import Path
+
             import questionary
+            import yaml
             from questionary import Choice, Style
             from rich.prompt import Prompt
 
+            from ...services.skills.selective_skill_deployer import (
+                get_skills_to_deploy,
+            )
+
             # Questionary style (matching agents configure)
             QUESTIONARY_STYLE = Style(
                 [
@@ -994,213 +1084,298 @@ class SkillsManagementCommand(BaseCommand):
                 ]
             )
 
-            console.print("\n[bold cyan]Interactive Skills Configuration[/bold cyan]\n")
+            console.print("\n[bold cyan]Skills Configuration Manager[/bold cyan]\n")
+
+            # Load current configuration
+            project_config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+            skills_to_deploy, current_mode = get_skills_to_deploy(project_config_path)
+
+            # Display current mode and skill count
+            console.print(f"[bold]Current Mode:[/bold] [cyan]{current_mode}[/cyan]")
             console.print(
-                "[dim]Select skills to install/uninstall using checkboxes[/dim]"
+                f"[bold]Active Skills:[/bold] {len(skills_to_deploy)} skills\n"
             )
-            console.print("[dim]● = Installed, ○ = Available[/dim]\n")
 
-            # Get deployed skills for status detection
-            deployed_result = self.skills_deployer.check_deployed_skills()
-            deployed_skills = {
-                skill["name"] for skill in deployed_result.get("skills", [])
-            }
+            if current_mode == "agent_referenced":
+                console.print(
+                    "[dim]Agent mode: Skills are auto-detected from deployed agents[/dim]"
+                )
+                console.print(
+                    "[dim]Switch to user mode to manually select skills[/dim]\n"
+                )
+            else:
+                console.print(
+                    "[dim]User mode: You've manually selected which skills to deploy[/dim]"
+                )
+                console.print("[dim]Reset to agent mode to use auto-detection[/dim]\n")
+
+            # Offer mode switching
+            action_choices = [
+                Choice("View current skills", value="view"),
+                Choice("Switch to user mode (manual selection)", value="switch_user"),
+                Choice("Reset to agent mode (auto-detection)", value="reset_agent"),
+                Choice("Cancel", value="cancel"),
+            ]
+
+            action = questionary.select(
+                "What would you like to do?",
+                choices=action_choices,
+                style=QUESTIONARY_STYLE,
+            ).ask()
+
+            if action == "cancel" or action is None:
+                console.print("[yellow]Configuration cancelled[/yellow]")
+                return CommandResult(success=True, exit_code=0)
 
-            # Get available skills from GitHub
-            console.print("[dim]Fetching available skills from GitHub...[/dim]\n")
-            available_result = self.skills_deployer.list_available_skills()
+            if action == "view":
+                # Display current skills
+                console.print("\n[bold]Current Skills:[/bold]\n")
+                for skill in sorted(skills_to_deploy):
+                    console.print(f"  • {skill}")
+                console.print()
+                Prompt.ask("\nPress Enter to continue")
+                return CommandResult(success=True, exit_code=0)
 
-            if available_result.get("error"):
-                console.print(f"[red]Error: {available_result['error']}[/red]")
-                return CommandResult(
-                    success=False, message=available_result["error"], exit_code=1
+            if action == "reset_agent":
+                # Reset to agent mode by clearing user_defined
+                with open(project_config_path, encoding="utf-8") as f:
+                    config = yaml.safe_load(f) or {}
+
+                if "skills" not in config:
+                    config["skills"] = {}
+
+                config["skills"]["user_defined"] = []
+
+                with open(project_config_path, "w", encoding="utf-8") as f:
+                    yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+                console.print(
+                    "\n[green]✓ Reset to agent mode - skills will be auto-detected from agents[/green]\n"
                 )
+                Prompt.ask("\nPress Enter to continue")
+                return CommandResult(success=True, exit_code=0)
 
-            # Flatten skills by category
-            all_skills = []
-            for category, skills in available_result.get("by_category", {}).items():
-                for skill in skills:
-                    skill_info = {
-                        "name": skill.get("name", "unknown"),
-                        "category": category,
-                        "is_deployed": skill.get("name", "unknown") in deployed_skills,
-                    }
-                    all_skills.append(skill_info)
+            # Switch to user mode - manual skill selection
+            if action == "switch_user":
+                console.print(
+                    "\n[bold cyan]Switching to User Mode - Manual Skill Selection[/bold cyan]\n"
+                )
+                console.print("[dim]Fetching available skills from GitHub...[/dim]\n")
 
-            # Sort by deployed status (deployed first), then by name
-            all_skills.sort(key=lambda s: (not s["is_deployed"], s["name"]))
+                # Get available skills
+                available_result = self.skills_deployer.list_available_skills()
 
-            # Build checkbox choices with pre-selection
-            # Loop to allow adjusting selection
-            while True:
-                skill_choices = []
-                skill_map = {}  # For lookup after selection
+                if available_result.get("error"):
+                    console.print(f"[red]Error: {available_result['error']}[/red]")
+                    return CommandResult(
+                        success=False, message=available_result["error"], exit_code=1
+                    )
 
-                for skill in all_skills:
-                    skill_name = skill["name"]
-                    category = skill["category"]
-                    is_deployed = skill["is_deployed"]
+                # Flatten skills by category
+                all_skills = []
+                for category, skills in available_result.get("by_category", {}).items():
+                    for skill in skills:
+                        skill_name = skill.get("name", "unknown")
+                        is_currently_selected = skill_name in skills_to_deploy
+                        skill_info = {
+                            "name": skill_name,
+                            "category": category,
+                            "is_selected": is_currently_selected,
+                        }
+                        all_skills.append(skill_info)
+
+                # Sort by selection status (selected first), then by name
+                all_skills.sort(key=lambda s: (not s["is_selected"], s["name"]))
+
+                # Build checkbox choices
+                while True:
+                    skill_choices = []
+
+                    for skill in all_skills:
+                        skill_name = skill["name"]
+                        category = skill["category"]
+                        is_selected = skill["is_selected"]
+
+                        # Format: "skill-name (category)"
+                        choice_text = f"{skill_name} ({category})"
+
+                        # Pre-select if currently in skills_to_deploy
+                        choice = Choice(
+                            title=choice_text, value=skill_name, checked=is_selected
+                        )
 
-                    # Simple format: "skill-name (category)"
-                    # Checkbox state (checked/unchecked) indicates installed status
-                    choice_text = f"{skill_name} ({category})"
+                        skill_choices.append(choice)
+
+                    # Display checkbox selection
+                    selected_skills = questionary.checkbox(
+                        "Select skills (Space to toggle, Enter to confirm):",
+                        choices=skill_choices,
+                        style=QUESTIONARY_STYLE,
+                    ).ask()
+
+                    if selected_skills is None:
+                        # User cancelled (Ctrl+C)
+                        console.print("[yellow]Skills configuration cancelled[/yellow]")
+                        return CommandResult(success=True, exit_code=0)
+
+                    # Show summary
+                    console.print("\n[bold]Selected Skills:[/bold]")
+                    console.print(f"  {len(selected_skills)} skills selected\n")
+
+                    if selected_skills:
+                        for skill in sorted(selected_skills):
+                            console.print(f"  • {skill}")
+                        console.print()
+
+                    # Ask user to confirm, adjust, or cancel
+                    confirm_action = questionary.select(
+                        "\nWhat would you like to do?",
+                        choices=[
+                            Choice("Save to configuration", value="apply"),
+                            Choice("Adjust selection", value="adjust"),
+                            Choice("Cancel", value="cancel"),
+                        ],
+                        default="apply",
+                        style=QUESTIONARY_STYLE,
+                    ).ask()
+
+                    if confirm_action == "cancel":
+                        console.print("[yellow]Configuration cancelled[/yellow]")
+                        Prompt.ask("\nPress Enter to continue")
+                        return CommandResult(success=True, exit_code=0)
+
+                    if confirm_action == "adjust":
+                        # Update selection state and loop back
+                        for skill in all_skills:
+                            skill["is_selected"] = skill["name"] in selected_skills
+                        console.print("\n[dim]Adjusting selection...[/dim]\n")
+                        continue
+
+                    # Save to configuration.yaml
+                    with open(project_config_path, encoding="utf-8") as f:
+                        config = yaml.safe_load(f) or {}
+
+                    if "skills" not in config:
+                        config["skills"] = {}
+
+                    config["skills"]["user_defined"] = sorted(selected_skills)
+
+                    with open(project_config_path, "w", encoding="utf-8") as f:
+                        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
 
-                    # Pre-select if deployed
-                    choice = Choice(
-                        title=choice_text, value=skill_name, checked=is_deployed
+                    console.print(
+                        f"\n[green]✓ Saved {len(selected_skills)} skills to user_defined mode[/green]"
+                    )
+                    console.print(
+                        "[yellow]⚠️  Important:[/yellow] Run [cyan]claude-mpm init[/cyan] to deploy these skills\n"
                     )
+                    Prompt.ask("\nPress Enter to continue")
 
-                    skill_choices.append(choice)
-                    skill_map[skill_name] = skill
+                    # Exit the loop after successful save
+                    break
 
-                # Display checkbox selection
-                selected_skills = questionary.checkbox(
-                    "Select skills (Space to toggle, Enter to confirm):",
-                    choices=skill_choices,
-                    style=QUESTIONARY_STYLE,
-                ).ask()
+            return CommandResult(success=True, exit_code=0)
 
-                if selected_skills is None:
-                    # User cancelled (Ctrl+C)
-                    console.print("[yellow]Skills configuration cancelled[/yellow]")
-                    return CommandResult(success=True, exit_code=0)
+        except Exception as e:
+            console.print(f"[red]Error in skills configuration: {e}[/red]")
+            import traceback
+
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
 
-                # Determine changes
-                to_install = []
-                to_remove = []
+    def _select_skills_interactive(self, args) -> CommandResult:
+        """Interactive skill selection with topic grouping.
 
-                for skill in all_skills:
-                    skill_name = skill["name"]
-                    is_deployed = skill["is_deployed"]
-                    is_selected = skill_name in selected_skills
+        This command provides a two-tier selection interface:
+        1. Select topic groups (toolchains) to explore
+        2. Multi-select skills within each topic group
 
-                    if is_selected and not is_deployed:
-                        to_install.append(skill_name)
-                    elif not is_selected and is_deployed:
-                        to_remove.append(skill_name)
+        Features:
+        - Groups skills by toolchain (universal, python, typescript, etc.)
+        - Shows skills auto-included by agent dependencies
+        - Displays token counts for each skill
+        - Updates config and runs reconciliation
 
-                # Show summary of changes
-                console.print("\n[bold]Changes to apply:[/bold]")
-                if to_install:
-                    console.print(
-                        f"\n[green]✓ Install ({len(to_install)} skills):[/green]"
-                    )
-                    for skill in to_install:
-                        console.print(f"  • {skill}")
+        Returns:
+            CommandResult with success/failure status
+        """
+        try:
+            from ...cli.interactive.skill_selector import run_skill_selector
+            from ...core.unified_config import UnifiedConfig
+            from ...services.agents.deployment.deployment_reconciler import (
+                DeploymentReconciler,
+            )
 
-                if to_remove:
+            console.print("\n[bold cyan]Interactive Skill Selector[/bold cyan]\n")
+
+            # Run skill selector
+            selected_skills = run_skill_selector()
+
+            if selected_skills is None:
+                console.print("\n[yellow]Skill selection cancelled[/yellow]")
+                return CommandResult(success=True, exit_code=0)
+
+            # Update config with selected skills
+            config = UnifiedConfig()
+            config.skills.enabled = selected_skills
+
+            # Save config
+            try:
+                config.save()
+                console.print(
+                    f"\n[green]✓ Saved {len(selected_skills)} skills to configuration[/green]"
+                )
+            except Exception as e:
+                console.print(f"\n[red]Failed to save configuration: {e}[/red]")
+                return CommandResult(success=False, message=str(e), exit_code=1)
+
+            # Run reconciliation to deploy skills
+            console.print("\n[cyan]Running skill reconciliation...[/cyan]")
+            reconciler = DeploymentReconciler(config)
+
+            try:
+                from pathlib import Path
+
+                project_path = Path.cwd()
+                result = reconciler.reconcile_skills(project_path)
+
+                if result.deployed:
                     console.print(
-                        f"\n[yellow]✗ Remove ({len(to_remove)} skills):[/yellow]"
+                        f"  [green]✓ Deployed: {', '.join(result.deployed)}[/green]"
                     )
-                    for skill in to_remove:
-                        console.print(f"  • {skill}")
-
-                if not to_install and not to_remove:
+                if result.removed:
                     console.print(
-                        "\n[dim]No changes (selection matches current deployment)[/dim]"
+                        f"  [yellow]✓ Removed: {', '.join(result.removed)}[/yellow]"
                     )
+                if result.errors:
+                    for error in result.errors:
+                        console.print(f"  [red]✗ {error}[/red]")
 
-                console.print()
-
-                # Ask user to confirm, adjust, or cancel
-                action = questionary.select(
-                    "\nWhat would you like to do?",
-                    choices=[
-                        Choice("Apply these changes", value="apply"),
-                        Choice("Adjust selection", value="adjust"),
-                        Choice("Cancel", value="cancel"),
-                    ],
-                    default="apply",
-                    style=QUESTIONARY_STYLE,
-                ).ask()
-
-                if action == "cancel":
-                    console.print("[yellow]Changes cancelled[/yellow]")
-                    Prompt.ask("\nPress Enter to continue")
-                    return CommandResult(success=True, exit_code=0)
-                if action == "adjust":
-                    # Loop back to skill selection
-                    console.print("\n[dim]Adjusting selection...[/dim]\n")
-                    continue
-
-                # Apply changes
-                success = True
-                errors = []
-
-                # Install skills
-                if to_install:
-                    console.print("\n[bold cyan]Installing skills...[/bold cyan]\n")
-                    for skill_name in to_install:
-                        try:
-                            # Deploy single skill
-                            result = self.skills_deployer.deploy_skills(
-                                skill_names=[skill_name], force=False
-                            )
-
-                            if result.get("errors"):
-                                errors.extend(result["errors"])
-                                success = False
-                            else:
-                                console.print(
-                                    f"[green]✓ Installed: {skill_name}[/green]"
-                                )
-                        except Exception as e:
-                            errors.append(f"Failed to install {skill_name}: {e}")
-                            success = False
-
-                # Remove skills
-                if to_remove:
-                    console.print("\n[bold yellow]Removing skills...[/bold yellow]\n")
-                    for skill_name in to_remove:
-                        try:
-                            # Remove single skill
-                            result = self.skills_deployer.remove_skills(
-                                skill_names=[skill_name]
-                            )
-
-                            if result.get("errors"):
-                                errors.extend(result["errors"])
-                                success = False
-                            else:
-                                console.print(
-                                    f"[yellow]✗ Removed: {skill_name}[/yellow]"
-                                )
-                        except Exception as e:
-                            errors.append(f"Failed to remove {skill_name}: {e}")
-                            success = False
-
-                # Show errors if any
-                if errors:
-                    console.print(f"\n[red]✗ {len(errors)} error(s):[/red]")
-                    for error in errors:
-                        console.print(f"  • {error}")
-
-                # Show restart instructions
-                if success and (to_install or to_remove):
+                if result.success:
                     console.print(
-                        "\n[bold green]✓ Changes applied successfully![/bold green]"
+                        "\n[bold green]✓ Skill deployment complete![/bold green]"
                     )
-                    console.print("\n[yellow]⚠️  Important:[/yellow]")
-                    console.print("  Restart Claude Code for changes to take effect")
-
-                console.print()
-                Prompt.ask("\nPress Enter to continue")
-
-                # Exit the loop after successful execution
-                break
+                    return CommandResult(success=True, exit_code=0)
+                console.print(
+                    f"\n[yellow]⚠ Deployment had {len(result.errors)} errors[/yellow]"
+                )
+                return CommandResult(
+                    success=False,
+                    message=f"{len(result.errors)} deployment errors",
+                    exit_code=1,
+                )
 
-            exit_code = 0 if success else 1
-            return CommandResult(success=success, exit_code=exit_code)
+            except Exception as e:
+                console.print(f"\n[red]Reconciliation failed: {e}[/red]")
+                return CommandResult(success=False, message=str(e), exit_code=1)
 
         except Exception as e:
-            console.print(f"[red]Error in skills configuration: {e}[/red]")
+            console.print(f"[red]Skill selection error: {e}[/red]")
             import traceback
 
             console.print(f"[dim]{traceback.format_exc()}[/dim]")
             return CommandResult(success=False, message=str(e), exit_code=1)
 
-            return CommandResult(success=False, message=str(e), exit_code=1)
-
 
 def manage_skills(args) -> int:
     """