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

claude_mpm/cli/commands/agents.py

@@ -21,11 +21,9 @@ from ...services.cli.agent_dependency_service import AgentDependencyService
 from ...services.cli.agent_listing_service import AgentListingService
 from ...services.cli.agent_output_formatter import AgentOutputFormatter
 from ...services.cli.agent_validation_service import AgentValidationService
-from ..shared import (
-    AgentCommand,
-    CommandResult,
-)
+from ..shared import AgentCommand, CommandResult
 from ..utils import get_agent_versions_display
+from .agents_cleanup import handle_agents_cleanup
 
 
 def _is_structured_output(args) -> bool:
@@ -149,6 +147,7 @@ class AgentsCommand(AgentCommand):
                 "deps-install": self._install_agent_dependencies,
                 "deps-list": self._list_agent_dependencies,
                 "deps-fix": self._fix_agent_dependencies,
+                "cleanup": lambda a: self._handle_cleanup_command(a),
                 "cleanup-orphaned": self._cleanup_orphaned_agents,
                 # Local agent management commands
                 "create": self._create_local_agent,
@@ -156,9 +155,24 @@ class AgentsCommand(AgentCommand):
                 "delete": self._delete_local_agent,
                 "manage": self._manage_local_agents,
                 "configure": self._configure_deployment,
+                # Migration command (DEPRECATION support)
+                "migrate-to-project": self._migrate_to_project,
                 # Auto-configuration commands (TSK-0054 Phase 5)
                 "detect": self._detect_toolchain,
                 "recommend": self._recommend_agents,
+                # Agent selection modes (Phase 3: 1M-382)
+                "deploy-minimal": self._deploy_minimal_configuration,
+                "deploy-auto": self._deploy_auto_configure,
+                # Agent source management (Phase 2: 1M-442)
+                "available": self._list_available_from_sources,
+                # Agent discovery with rich filtering (Phase 1: Discovery & Browsing)
+                "discover": self._discover_agents,
+                # Cache git management commands
+                "cache-status": self._cache_status,
+                "cache-pull": self._cache_pull,
+                "cache-push": self._cache_push,
+                "cache-sync": self._cache_sync,
+                "cache-commit": self._cache_commit,
             }
 
             if args.agents_command in command_map:
@@ -396,31 +410,210 @@ class AgentsCommand(AgentCommand):
             self.logger.error(f"Error listing agents by tier: {e}", exc_info=True)
             return CommandResult.error_result(f"Error listing agents by tier: {e}")
 
+    def _list_available_from_sources(self, args) -> CommandResult:
+        """List available agents from all configured git sources.
+
+        This command shows agents discovered from configured agent sources
+        (Git repositories) after syncing their cache. Implements Phase 2 of 1M-442.
+
+        Args:
+            args: Command arguments with optional source filter and format
+
+        Returns:
+            CommandResult with agent list or error
+        """
+        try:
+            from ...config.agent_sources import AgentSourceConfiguration
+            from ...services.agents.git_source_manager import GitSourceManager
+
+            # Load agent sources configuration
+            config = AgentSourceConfiguration.load()
+            enabled_repos = [r for r in config.repositories if r.enabled]
+
+            if not enabled_repos:
+                message = (
+                    "No agent sources configured.\n\n"
+                    "Configure sources with:\n"
+                    "  claude-mpm agent-source add <url>\n\n"
+                    "Example:\n"
+                    "  claude-mpm agent-source add https://github.com/owner/repo/agents"
+                )
+                print(message)
+                return CommandResult.error_result("No agent sources configured")
+
+            # Initialize git source manager
+            manager = GitSourceManager()
+
+            # Sync all configured sources (with timeout)
+            self.logger.info(f"Syncing {len(enabled_repos)} agent sources...")
+            sync_results = {}
+
+            for repo in enabled_repos:
+                try:
+                    result = manager.sync_repository(repo, force=False)
+                    sync_results[repo.identifier] = result
+                except Exception as e:
+                    self.logger.warning(f"Failed to sync {repo.identifier}: {e}")
+                    sync_results[repo.identifier] = {"synced": False, "error": str(e)}
+
+            # Get source filter from args
+            source_filter = getattr(args, "source", None)
+
+            # List all cached agents
+            all_agents = manager.list_cached_agents(repo_identifier=source_filter)
+
+            if not all_agents:
+                message = "No agents found in configured sources."
+                if sync_results:
+                    failed_count = sum(
+                        1 for r in sync_results.values() if not r.get("synced")
+                    )
+                    if failed_count > 0:
+                        message += f"\n\n{failed_count} source(s) failed to sync. Check logs for details."
+                print(message)
+                return CommandResult.success_result(message, data={"agents": []})
+
+            # Format output
+            output_format = getattr(args, "format", "table")
+
+            if output_format == "json":
+                import json
+
+                print(json.dumps(all_agents, indent=2))
+            elif output_format == "simple":
+                for agent in all_agents:
+                    name = agent.get("metadata", {}).get(
+                        "name", agent.get("agent_id", "unknown")
+                    )
+                    repo = agent.get("repository", "unknown")
+                    print(f"{name} (from {repo})")
+            else:  # table format
+                print(f"\n{'Agent Name':<30} {'Repository':<40} {'Version':<15}")
+                print("=" * 85)
+                for agent in all_agents:
+                    name = agent.get("metadata", {}).get(
+                        "name", agent.get("agent_id", "unknown")
+                    )
+                    repo = agent.get("repository", "unknown")
+                    version = agent.get("version", "unknown")[:12]
+                    print(f"{name:<30} {repo:<40} {version:<15}")
+                print(
+                    f"\nTotal: {len(all_agents)} agents from {len(sync_results)} sources"
+                )
+
+            return CommandResult.success_result(
+                f"Listed {len(all_agents)} agents from sources",
+                data={"agents": all_agents, "sync_results": sync_results},
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error listing available agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error listing available agents: {e}")
+
+    def _discover_agents(self, args) -> CommandResult:
+        """Discover agents with rich filtering capabilities.
+
+        This command extends the 'available' command by adding semantic filtering
+        based on AUTO-DEPLOY-INDEX.md categories. Users can filter by category,
+        language, framework, platform, and specialization.
+
+        Design Decision: Delegate to agents_discover.py module
+
+        Rationale: Keep CLI command logic separate from routing logic for better
+        testability and maintainability. The discover_command function handles
+        all the complex filtering and formatting logic.
+
+        Args:
+            args: Command arguments with filter options:
+                - source: Source repository filter
+                - category: Category filter (e.g., 'engineer/backend')
+                - language: Language filter (e.g., 'python')
+                - framework: Framework filter (e.g., 'react')
+                - platform: Platform filter (e.g., 'vercel')
+                - specialization: Specialization filter (e.g., 'data')
+                - format: Output format (table, json, simple)
+                - verbose: Show descriptions and metadata
+
+        Returns:
+            CommandResult with filtered agent list or error
+
+        Example:
+            >>> # Called via: claude-mpm agents discover --category engineer/backend
+            >>> _discover_agents(args)
+            CommandResult(success=True, message="Discovered 8 agents")
+        """
+        try:
+            from .agents_discover import discover_command
+
+            # Call discover_command and convert exit code to CommandResult
+            exit_code = discover_command(args)
+
+            if exit_code == 0:
+                return CommandResult.success_result("Agent discovery complete")
+            return CommandResult.error_result("Agent discovery failed")
+
+        except Exception as e:
+            self.logger.error(f"Error discovering agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error discovering agents: {e}")
+
     def _deploy_agents(self, args, force=False) -> CommandResult:
-        """Deploy both system and project agents."""
+        """Deploy agents using two-phase sync: cache → deploy.
+
+        Phase 3 Integration (1M-486): Uses Git sync service for deployment.
+        - Phase 1: Sync agents to ~/.claude-mpm/cache/remote-agents/ (if needed)
+        - Phase 2: Deploy from cache to project .claude-mpm/agents/
+
+        This replaces the old single-tier deployment with a multi-project
+        architecture where one cache serves multiple project deployments.
+        """
         try:
-            # Deploy system agents
-            system_result = self.deployment_service.deploy_system_agents(force=force)
+            # Handle preset deployment (uses different path)
+            if hasattr(args, "preset") and args.preset:
+                return self._deploy_preset(args)
+
+            from ...services.agents.sources.git_source_sync_service import (
+                GitSourceSyncService,
+            )
+
+            # Initialize git sync service
+            git_sync = GitSourceSyncService()
+            project_dir = Path.cwd()
 
-            # Deploy project agents if they exist
-            project_result = self.deployment_service.deploy_project_agents(force=force)
+            self.logger.info("Phase 1: Syncing agents to cache...")
 
-            # Combine results
+            # Sync to cache (downloads from GitHub if needed)
+            sync_result = git_sync.sync_repository(force=force)
+
+            if not sync_result.get("synced"):
+                error_msg = sync_result.get("error", "Unknown sync error")
+                self.logger.error(f"Sync failed: {error_msg}")
+                return CommandResult.error_result(f"Sync failed: {error_msg}")
+
+            self.logger.info(
+                f"Phase 1 complete: {sync_result.get('agent_count', 0)} agents in cache"
+            )
+            self.logger.info(f"Phase 2: Deploying agents to {project_dir}...")
+
+            # Deploy from cache to project directory
+            deploy_result = git_sync.deploy_agents_to_project(
+                project_dir=project_dir,
+                agent_list=None,  # Deploy all cached agents
+                force=force,
+            )
+
+            # Format combined results for output
             combined_result = {
-                "deployed_count": system_result.get("deployed_count", 0)
-                + project_result.get("deployed_count", 0),
-                "deployed": system_result.get("deployed", [])
-                + project_result.get("deployed", []),
-                "updated_count": system_result.get("updated_count", 0)
-                + project_result.get("updated_count", 0),
-                "updated": system_result.get("updated", [])
-                + project_result.get("updated", []),
-                "skipped": system_result.get("skipped", [])
-                + project_result.get("skipped", []),
-                "errors": system_result.get("errors", [])
-                + project_result.get("errors", []),
-                "target_dir": system_result.get("target_dir")
-                or project_result.get("target_dir"),
+                "deployed_count": len(deploy_result.get("deployed", []))
+                + len(deploy_result.get("updated", [])),
+                "deployed": deploy_result.get("deployed", []),
+                "updated": deploy_result.get("updated", []),
+                "skipped": deploy_result.get("skipped", []),
+                "errors": deploy_result.get("failed", []),
+                "target_dir": deploy_result.get("deployment_dir", ""),
+                "sync_info": {
+                    "cached_agents": sync_result.get("agent_count", 0),
+                    "cache_dir": sync_result.get("cache_dir", ""),
+                },
             }
 
             output_format = self._get_output_format(args)
@@ -431,12 +624,15 @@ class AgentsCommand(AgentCommand):
             )
             print(formatted)
 
+            success_count = len(deploy_result["deployed"]) + len(
+                deploy_result["updated"]
+            )
             return CommandResult.success_result(
-                f"Deployed {combined_result['deployed_count']} agents",
+                f"Deployed {success_count} agents from cache",
                 data={
-                    "system_agents": system_result,
-                    "project_agents": project_result,
-                    "total_deployed": combined_result["deployed_count"],
+                    "sync_result": sync_result,
+                    "deploy_result": deploy_result,
+                    "total_deployed": success_count,
                 },
             )
 
@@ -444,6 +640,173 @@ class AgentsCommand(AgentCommand):
             self.logger.error(f"Error deploying agents: {e}", exc_info=True)
             return CommandResult.error_result(f"Error deploying agents: {e}")
 
+    def _deploy_preset(self, args) -> CommandResult:
+        """Deploy agents by preset name.
+
+        This method implements Phase 2 of the agents/skills CLI redesign,
+        enabling preset-based deployment like:
+            claude-mpm agents deploy --preset python-dev
+
+        Args:
+            args: Command arguments with preset name and optional flags
+
+        Returns:
+            CommandResult with deployment status
+        """
+        try:
+            from pathlib import Path
+
+            from ...config.agent_sources import AgentSourceConfiguration
+            from ...services.agents.agent_preset_service import AgentPresetService
+            from ...services.agents.git_source_manager import GitSourceManager
+            from ...services.agents.single_tier_deployment_service import (
+                SingleTierDeploymentService,
+            )
+
+            preset_name = args.preset
+            dry_run = getattr(args, "dry_run", False)
+
+            # Initialize services
+            config = AgentSourceConfiguration.load()
+            deployment_dir = Path.home() / ".claude" / "agents"
+            git_source_manager = GitSourceManager()
+            preset_service = AgentPresetService(git_source_manager)
+            deployment_service = SingleTierDeploymentService(config, deployment_dir)
+
+            # Validate preset
+            if not preset_service.validate_preset(preset_name):
+                available = preset_service.list_presets()
+                print(f"❌ Unknown preset: {preset_name}")
+                print("\n📚 Available presets:")
+                for preset in available:
+                    print(
+                        f"  • {preset['name']}: {preset['description']} ({preset['agent_count']} agents)"
+                    )
+                    print(f"    Use cases: {', '.join(preset['use_cases'])}")
+                return CommandResult.error_result(f"Unknown preset: {preset_name}")
+
+            # Resolve preset to agent list
+            print(f"\n🔍 Resolving preset: {preset_name}")
+            resolution = preset_service.resolve_agents(
+                preset_name, validate_availability=True
+            )
+
+            # Show preset info
+            preset_info = resolution["preset_info"]
+            print(f"\n🎯 Preset: {preset_info['description']}")
+            print(f"   Agents: {preset_info['agent_count']}")
+            print(f"   Use cases: {', '.join(preset_info['use_cases'])}")
+
+            # Show warnings for missing agents
+            if resolution["missing_agents"]:
+                print("\n⚠️  Missing agents (not found in configured sources):")
+                for agent_id in resolution["missing_agents"]:
+                    print(f"    • {agent_id}")
+                print("\n💡 These agents are not available in your configured sources.")
+                print("   Deployment will continue with available agents.")
+
+            # Show conflicts
+            if resolution["conflicts"]:
+                print("\n⚠️  Priority conflicts detected:")
+                for conflict in resolution["conflicts"]:
+                    sources = ", ".join(conflict["sources"])
+                    print(f"    • {conflict['agent_id']} (found in: {sources})")
+                print("    Using highest priority source for each")
+
+            # Dry run mode
+            if dry_run:
+                print("\n🔍 DRY RUN: Preview agent deployment\n")
+                print("Agents to deploy:")
+                for agent in resolution["agents"]:
+                    source = agent.get("source", "unknown")
+                    print(f"  ✓ {agent['agent_id']} (from {source})")
+                print(
+                    "\n💡 This is a dry run. Run without --dry-run to actually deploy."
+                )
+                return CommandResult.success_result(
+                    "Dry run complete",
+                    data={
+                        "preset": preset_name,
+                        "agents": resolution["agents"],
+                        "missing": resolution["missing_agents"],
+                    },
+                )
+
+            # Deploy agents
+            print(f"\n📦 Deploying {len(resolution['agents'])} agents...")
+            deployed_count = 0
+            failed_count = 0
+            skipped_count = len(resolution["missing_agents"])
+            deployed_agents = []
+            failed_agents = []
+
+            for agent in resolution["agents"]:
+                agent_id = agent["agent_id"]
+                try:
+                    # Deploy using single-tier deployment service
+                    result = deployment_service.deploy_agent(
+                        agent_id, source_repo=agent.get("source"), dry_run=False
+                    )
+
+                    if result.get("deployed"):
+                        deployed_count += 1
+                        deployed_agents.append(agent_id)
+                        print(f"  ✓ {agent_id}")
+                    else:
+                        failed_count += 1
+                        failed_agents.append(
+                            {
+                                "agent_id": agent_id,
+                                "error": result.get("error", "Unknown"),
+                            }
+                        )
+                        print(f"  ✗ {agent_id}: {result.get('error', 'Failed')}")
+
+                except Exception as e:
+                    failed_count += 1
+                    failed_agents.append({"agent_id": agent_id, "error": str(e)})
+                    print(f"  ✗ {agent_id}: {e}")
+
+            # Summary
+            print(f"\n{'=' * 60}")
+            print("📊 Deployment Summary")
+            print(f"{'=' * 60}")
+            print(f"  ✅ Deployed: {deployed_count}")
+            print(f"  ❌ Failed: {failed_count}")
+            print(f"  ⏭️  Skipped: {skipped_count} (missing from sources)")
+            print(f"{'=' * 60}\n")
+
+            if failed_agents:
+                print("❌ Failed agents:")
+                for failure in failed_agents:
+                    print(f"  • {failure['agent_id']}: {failure['error']}")
+                print()
+
+            if deployed_count > 0:
+                print(f"✅ Successfully deployed {deployed_count} agents!")
+                return CommandResult.success_result(
+                    f"Deployed {deployed_count} agents from preset '{preset_name}'",
+                    data={
+                        "preset": preset_name,
+                        "deployed": deployed_agents,
+                        "failed": failed_agents,
+                        "skipped": resolution["missing_agents"],
+                    },
+                )
+            return CommandResult.error_result(
+                f"No agents deployed from preset '{preset_name}'",
+                data={
+                    "preset": preset_name,
+                    "failed": failed_agents,
+                    "skipped": resolution["missing_agents"],
+                },
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error deploying preset: {e}", exc_info=True)
+            print(f"\n❌ Error deploying preset: {e}")
+            return CommandResult.error_result(f"Error deploying preset: {e}")
+
     def _clean_agents(self, args) -> CommandResult:
         """Clean deployed agents."""
         try:
@@ -904,6 +1267,16 @@ class AgentsCommand(AgentCommand):
             self.logger.error(f"Error fixing dependencies: {e}", exc_info=True)
             return CommandResult.error_result(f"Error fixing dependencies: {e}")
 
+    def _handle_cleanup_command(self, args) -> CommandResult:
+        """Handle cleanup command with proper result wrapping."""
+        exit_code = handle_agents_cleanup(args)
+        return CommandResult(
+            success=exit_code == 0,
+            message=(
+                "Agent cleanup complete" if exit_code == 0 else "Agent cleanup failed"
+            ),
+        )
+
     def _cleanup_orphaned_agents(self, args) -> CommandResult:
         """Clean up orphaned agents that don't have templates."""
         try:
@@ -1125,18 +1498,46 @@ class AgentsCommand(AgentCommand):
             return CommandResult.error_result(f"Error deleting local agents: {e}")
 
     def _manage_local_agents(self, args) -> CommandResult:
-        """Launch interactive management menu for local agents."""
+        """Redirect to main configuration interface (DEPRECATED)."""
         try:
-            from ..interactive.agent_wizard import run_interactive_agent_manager
+            from rich.console import Console
+            from rich.prompt import Confirm
 
-            exit_code = run_interactive_agent_manager()
-            if exit_code == 0:
-                return CommandResult.success_result("Agent management completed")
-            return CommandResult.error_result("Agent management failed or cancelled")
+            console = Console()
+
+            console.print(
+                "\n[bold cyan]╭─────────────────────────────────────────╮[/bold cyan]"
+            )
+            console.print(
+                "[bold cyan]│  Agent Management Has Moved!            │[/bold cyan]"
+            )
+            console.print(
+                "[bold cyan]╰─────────────────────────────────────────╯[/bold cyan]\n"
+            )
+
+            console.print("For a better experience with integrated configuration:")
+            console.print("  • Agent management")
+            console.print("  • Skills management")
+            console.print("  • Template editing")
+            console.print("  • Behavior configuration")
+            console.print("  • Startup settings\n")
+
+            console.print("Please use: [bold green]claude-mpm config[/bold green]\n")
+
+            if Confirm.ask("Launch configuration interface now?", default=True):
+                # Import and run config command directly
+                from claude_mpm.cli.commands.configure import ConfigureCommand
+
+                config_cmd = ConfigureCommand()
+                return config_cmd.execute(args)
+            console.print(
+                "\n[dim]Run 'claude-mpm config' anytime to access agent management[/dim]"
+            )
+            return CommandResult.success_result("Redirected to config interface")
 
         except Exception as e:
-            self.logger.error(f"Error managing local agents: {e}", exc_info=True)
-            return CommandResult.error_result(f"Error managing local agents: {e}")
+            self.logger.error(f"Error redirecting to config: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error redirecting to config: {e}")
 
     def _configure_deployment(self, args) -> CommandResult:
         """Configure agent deployment settings."""
@@ -1448,6 +1849,528 @@ class AgentsCommand(AgentCommand):
             self.logger.error(f"Error recommending agents: {e}", exc_info=True)
             return CommandResult.error_result(f"Error recommending agents: {e}")
 
+    def _migrate_to_project(self, args) -> CommandResult:
+        """Migrate user-level agents to project-level.
+
+        DEPRECATION: User-level agents (~/.claude-mpm/agents/) are deprecated and
+        will be removed in v5.0.0. This command migrates them to project-level
+        (.claude-mpm/agents/) where they belong.
+
+        Args:
+            args: Command arguments with dry_run and force flags
+
+        Returns:
+            CommandResult with migration status
+        """
+        import shutil
+
+        try:
+            user_agents_dir = Path.home() / ".claude-mpm" / "agents"
+            project_agents_dir = Path.cwd() / ".claude-mpm" / "agents"
+
+            dry_run = getattr(args, "dry_run", False)
+            force = getattr(args, "force", False)
+
+            # Check if user agents directory exists
+            if not user_agents_dir.exists():
+                print("✅ No user-level agents found. Nothing to migrate.")
+                return CommandResult.success_result("No user-level agents to migrate")
+
+            # Find all user agent files
+            user_agent_files = list(user_agents_dir.glob("*.json")) + list(
+                user_agents_dir.glob("*.md")
+            )
+
+            if not user_agent_files:
+                print("✅ No user-level agents found. Nothing to migrate.")
+                return CommandResult.success_result("No user-level agents to migrate")
+
+            # Display what we found
+            print(f"\n📦 Found {len(user_agent_files)} user-level agent(s) to migrate:")
+            for agent_file in user_agent_files:
+                print(f"  - {agent_file.name}")
+
+            if dry_run:
+                print("\n🔍 DRY RUN: Would migrate to:")
+                print(f"  → {project_agents_dir}")
+                print("\nRun without --dry-run to perform the migration.")
+                return CommandResult.success_result(
+                    "Dry run completed",
+                    data={
+                        "user_agents_found": len(user_agent_files),
+                        "target_directory": str(project_agents_dir),
+                    },
+                )
+
+            # Create project agents directory
+            project_agents_dir.mkdir(parents=True, exist_ok=True)
+
+            # Migrate agents
+            migrated = 0
+            skipped = 0
+            errors = []
+
+            for agent_file in user_agent_files:
+                target_file = project_agents_dir / agent_file.name
+
+                # Check for conflicts
+                if target_file.exists() and not force:
+                    print(f"⚠️  Skipping {agent_file.name} (already exists in project)")
+                    print("   Use --force to overwrite existing agents")
+                    skipped += 1
+                    continue
+
+                try:
+                    # Copy agent to project directory
+                    shutil.copy2(agent_file, target_file)
+                    migrated += 1
+                    print(f"✅ Migrated {agent_file.name}")
+                except Exception as e:
+                    error_msg = f"Failed to migrate {agent_file.name}: {e}"
+                    errors.append(error_msg)
+                    print(f"❌ {error_msg}")
+
+            # Summary
+            print("\n📊 Migration Summary:")
+            print(f"  ✅ Migrated: {migrated}/{len(user_agent_files)}")
+            if skipped > 0:
+                print(f"  ⏭️  Skipped: {skipped} (already exist)")
+            if errors:
+                print(f"  ❌ Errors: {len(errors)}")
+
+            if migrated > 0:
+                print(f"\n✅ Successfully migrated {migrated} agent(s) to:")
+                print(f"   {project_agents_dir}")
+                print(
+                    "\n⚠️  IMPORTANT: Verify agents work correctly, then remove user-level agents:"
+                )
+                print(f"   rm -rf {user_agents_dir}")
+                print("\n💡 Why this change?")
+                print("   - Project isolation: Each project has its own agents")
+                print("   - Version control: Agents can be versioned with your code")
+                print("   - Team consistency: Everyone uses the same agents")
+
+            return CommandResult.success_result(
+                f"Migrated {migrated} agents",
+                data={
+                    "migrated": migrated,
+                    "skipped": skipped,
+                    "errors": errors,
+                    "total": len(user_agent_files),
+                },
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error migrating agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error migrating agents: {e}")
+
+    def _deploy_minimal_configuration(self, args) -> CommandResult:
+        """Deploy minimal configuration (6 core agents).
+
+        Part of Phase 3 (1M-382): Agent Selection Modes.
+        Deploy exactly 6 agents for basic Claude MPM workflow:
+        engineer, documentation, qa, research, ops, ticketing.
+        """
+        try:
+            from ...config.agent_sources import AgentSourceConfiguration
+            from ...services.agents.agent_selection_service import AgentSelectionService
+            from ...services.agents.single_tier_deployment_service import (
+                SingleTierDeploymentService,
+            )
+
+            # Initialize services
+            config = AgentSourceConfiguration.load()
+            deployment_dir = Path.home() / ".claude" / "agents"
+            deployment_service = SingleTierDeploymentService(config, deployment_dir)
+            selection_service = AgentSelectionService(deployment_service)
+
+            # Get dry_run flag
+            dry_run = getattr(args, "dry_run", False)
+
+            # Deploy minimal configuration
+            print("🎯 Deploying minimal configuration (6 core agents)...")
+            if dry_run:
+                print("🔍 DRY RUN MODE - No agents will be deployed\n")
+
+            result = selection_service.deploy_minimal_configuration(dry_run=dry_run)
+
+            # Format output
+            output_format = self._get_output_format(args)
+            if self._is_structured_format(output_format):
+                formatted = (
+                    self._formatter.format_as_json(result)
+                    if str(output_format).lower() == OutputFormat.JSON
+                    else self._formatter.format_as_yaml(result)
+                )
+                print(formatted)
+                return CommandResult.success_result(
+                    f"Minimal configuration {result['status']}", data=result
+                )
+
+            # Text output
+            print(f"\n{'=' * 60}")
+            print(f"Status: {result['status'].upper()}")
+            print(f"Mode: {result['mode']}")
+            print(f"{'=' * 60}")
+            print(
+                f"\n📊 Summary: {result['deployed_count']} deployed, "
+                f"{result['failed_count']} failed, {result['missing_count']} missing"
+            )
+
+            if result["deployed_agents"]:
+                print(f"\n✅ Deployed agents ({len(result['deployed_agents'])}):")
+                for agent in result["deployed_agents"]:
+                    print(f"  • {agent}")
+
+            if result["failed_agents"]:
+                print(f"\n❌ Failed agents ({len(result['failed_agents'])}):")
+                for agent in result["failed_agents"]:
+                    print(f"  • {agent}")
+
+            if result["missing_agents"]:
+                print(f"\n⚠️  Missing agents ({len(result['missing_agents'])}):")
+                for agent in result["missing_agents"]:
+                    print(f"  • {agent}")
+                print("\nThese agents are not available in configured sources.")
+
+            if dry_run:
+                print(
+                    "\n💡 This was a dry run. Run without --dry-run to deploy agents."
+                )
+
+            return CommandResult.success_result(
+                f"Minimal configuration {result['status']}", data=result
+            )
+
+        except Exception as e:
+            self.logger.error(
+                f"Error deploying minimal configuration: {e}", exc_info=True
+            )
+            return CommandResult.error_result(
+                f"Error deploying minimal configuration: {e}"
+            )
+
+    def _deploy_auto_configure(self, args) -> CommandResult:
+        """Auto-detect toolchain and deploy matching agents.
+
+        Part of Phase 3 (1M-382): Agent Selection Modes.
+        Detect project toolchain (languages, frameworks, build tools) and
+        deploy matching specialized agents.
+        """
+        try:
+            from ...config.agent_sources import AgentSourceConfiguration
+            from ...services.agents.agent_selection_service import AgentSelectionService
+            from ...services.agents.single_tier_deployment_service import (
+                SingleTierDeploymentService,
+            )
+
+            # Initialize services
+            config = AgentSourceConfiguration.load()
+            deployment_dir = Path.home() / ".claude" / "agents"
+            deployment_service = SingleTierDeploymentService(config, deployment_dir)
+            selection_service = AgentSelectionService(deployment_service)
+
+            # Get arguments
+            project_path = getattr(args, "path", Path.cwd())
+            dry_run = getattr(args, "dry_run", False)
+
+            # Deploy auto-configure
+            print(f"🔍 Auto-detecting toolchain in {project_path}...")
+            if dry_run:
+                print("🔍 DRY RUN MODE - No agents will be deployed\n")
+
+            result = selection_service.deploy_auto_configure(
+                project_path=project_path, dry_run=dry_run
+            )
+
+            # Format output
+            output_format = self._get_output_format(args)
+            if self._is_structured_format(output_format):
+                formatted = (
+                    self._formatter.format_as_json(result)
+                    if str(output_format).lower() == OutputFormat.JSON
+                    else self._formatter.format_as_yaml(result)
+                )
+                print(formatted)
+                return CommandResult.success_result(
+                    f"Auto-configure {result['status']}", data=result
+                )
+
+            # Text output
+            print(f"\n{'=' * 60}")
+            print(f"Status: {result['status'].upper()}")
+            print(f"Mode: {result['mode']}")
+            print(f"{'=' * 60}")
+
+            # Show detected toolchain
+            toolchain = result.get("toolchain", {})
+            print("\n🔧 Detected Toolchain:")
+            if toolchain.get("languages"):
+                print(f"  Languages: {', '.join(toolchain['languages'])}")
+            if toolchain.get("frameworks"):
+                print(f"  Frameworks: {', '.join(toolchain['frameworks'])}")
+            if toolchain.get("build_tools"):
+                print(f"  Build Tools: {', '.join(toolchain['build_tools'])}")
+
+            if not any(toolchain.values()):
+                print("  (No toolchain detected)")
+
+            # Show recommended agents
+            recommended = result.get("recommended_agents", [])
+            if recommended:
+                print(f"\n🎯 Recommended agents ({len(recommended)}):")
+                for agent in recommended:
+                    print(f"  • {agent}")
+
+            # Show deployment summary
+            print(
+                f"\n📊 Summary: {result['deployed_count']} deployed, "
+                f"{result['failed_count']} failed, {result['missing_count']} missing"
+            )
+
+            if result.get("deployed_agents"):
+                print(f"\n✅ Deployed agents ({len(result['deployed_agents'])}):")
+                for agent in result["deployed_agents"]:
+                    print(f"  • {agent}")
+
+            if result.get("failed_agents"):
+                print(f"\n❌ Failed agents ({len(result['failed_agents'])}):")
+                for agent in result["failed_agents"]:
+                    print(f"  • {agent}")
+
+            if result.get("missing_agents"):
+                print(f"\n⚠️  Missing agents ({len(result['missing_agents'])}):")
+                for agent in result["missing_agents"]:
+                    print(f"  • {agent}")
+                print("\nThese agents are not available in configured sources.")
+
+            if dry_run:
+                print(
+                    "\n💡 This was a dry run. Run without --dry-run to deploy agents."
+                )
+
+            return CommandResult.success_result(
+                f"Auto-configure {result['status']}", data=result
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error in auto-configure: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error in auto-configure: {e}")
+
+    def _cache_status(self, args) -> CommandResult:
+        """Show git status of agent cache.
+
+        Displays current branch, uncommitted changes, unpushed commits, and
+        remote URL for the agent cache repository.
+        """
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                print(f"\nCache location: {cache_dir}")
+                print(
+                    "\n💡 This is expected if you haven't cloned the agents repository."
+                )
+                print("   The cache will be managed via HTTP sync instead.")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            status = manager.get_status()
+            output_format = self._get_output_format(args)
+
+            if self._is_structured_format(output_format):
+                formatted = (
+                    self._formatter.format_as_json(status)
+                    if str(output_format).lower() == OutputFormat.JSON
+                    else self._formatter.format_as_yaml(status)
+                )
+                print(formatted)
+                return CommandResult.success_result(
+                    "Cache status retrieved", data=status
+                )
+
+            # Text output
+            print(f"\n📁 Cache: {manager.repo_path}")
+            print(f"🌿 Branch: {status.get('branch', 'unknown')}")
+
+            if status.get("remote_url"):
+                print(f"🔗 Remote: {status['remote_url']}")
+
+            # Show sync status
+            ahead = status.get("ahead", 0)
+            behind = status.get("behind", 0)
+
+            if ahead > 0:
+                print(f"📤 Ahead of remote: {ahead} commit(s)")
+            if behind > 0:
+                print(f"📥 Behind remote: {behind} commit(s)")
+
+            if ahead == 0 and behind == 0:
+                print("✅ In sync with remote")
+
+            # Show uncommitted changes
+            uncommitted = status.get("uncommitted", [])
+            if uncommitted:
+                print(f"\n⚠️  Uncommitted changes: {len(uncommitted)}")
+                for file in uncommitted[:10]:  # Show max 10 files
+                    print(f"   - {file}")
+                if len(uncommitted) > 10:
+                    print(f"   ... and {len(uncommitted) - 10} more")
+            else:
+                print("\n✅ No uncommitted changes")
+
+            # Overall status
+            if status.get("is_clean"):
+                print("\n✨ Cache is clean and up-to-date")
+            else:
+                print("\n💡 Run 'claude-mpm agents cache-sync' to sync with remote")
+
+            return CommandResult.success_result("Cache status displayed", data=status)
+
+        except Exception as e:
+            self.logger.error(f"Error getting cache status: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error getting cache status: {e}")
+
+    def _cache_pull(self, args) -> CommandResult:
+        """Pull latest agents from remote repository."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            branch = getattr(args, "branch", "main")
+            print(f"🔄 Pulling latest changes from {branch}...")
+
+            success, msg = manager.pull_latest(branch)
+
+            if success:
+                print(f"✅ {msg}")
+                return CommandResult.success_result(msg)
+            print(f"❌ {msg}")
+            return CommandResult.error_result(msg)
+
+        except Exception as e:
+            self.logger.error(f"Error pulling cache: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error pulling cache: {e}")
+
+    def _cache_commit(self, args) -> CommandResult:
+        """Commit changes to cache repository."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            # Get commit message from args
+            message = getattr(args, "message", None)
+            if not message:
+                # Default message
+                message = "feat: update agents from local development"
+
+            print("💾 Committing changes...")
+            success, msg = manager.commit_changes(message)
+
+            if success:
+                print(f"✅ {msg}")
+                print(f"\n💡 Commit message: {message}")
+                return CommandResult.success_result(msg)
+            print(f"❌ {msg}")
+            return CommandResult.error_result(msg)
+
+        except Exception as e:
+            self.logger.error(f"Error committing cache changes: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error committing cache changes: {e}")
+
+    def _cache_push(self, args) -> CommandResult:
+        """Push local agent changes to remote."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            # Check for uncommitted changes
+            if manager.has_uncommitted_changes():
+                print("⚠️  You have uncommitted changes.")
+                print("\n💡 Commit changes first with:")
+                print("   claude-mpm agents cache-commit --message 'your message'")
+
+                # Ask if user wants to commit first
+                auto_commit = getattr(args, "auto_commit", False)
+                if auto_commit:
+                    print("\n📝 Auto-committing changes...")
+                    success, msg = manager.commit_changes("feat: update agents")
+                    if not success:
+                        print(f"❌ Commit failed: {msg}")
+                        return CommandResult.error_result(f"Commit failed: {msg}")
+                    print(f"✅ {msg}")
+                else:
+                    return CommandResult.error_result(
+                        "Uncommitted changes detected. Commit first or use --auto-commit"
+                    )
+
+            # Push changes
+            branch = getattr(args, "branch", "main")
+            print(f"📤 Pushing changes to {branch}...")
+
+            success, msg = manager.push_changes(branch)
+
+            if success:
+                print(f"✅ {msg}")
+                return CommandResult.success_result(msg)
+            print(f"❌ {msg}")
+            return CommandResult.error_result(msg)
+
+        except Exception as e:
+            self.logger.error(f"Error pushing cache: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error pushing cache: {e}")
+
+    def _cache_sync(self, args) -> CommandResult:
+        """Full cache sync: pull, commit (if needed), push."""
+        try:
+            from ...services.agents.cache_git_manager import CacheGitManager
+
+            cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+            manager = CacheGitManager(cache_dir)
+
+            if not manager.is_git_repo():
+                print("❌ Cache is not a git repository")
+                return CommandResult.error_result("Cache is not a git repository")
+
+            print("🔄 Syncing cache with remote...\n")
+
+            success, msg = manager.sync_with_remote()
+
+            # Print detailed sync message
+            print(msg)
+
+            if success:
+                print("\n✨ Cache sync complete!")
+                return CommandResult.success_result("Cache synced successfully")
+
+            print("\n❌ Cache sync failed. See details above.")
+            return CommandResult.error_result("Cache sync failed")
+
+        except Exception as e:
+            self.logger.error(f"Error syncing cache: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error syncing cache: {e}")
+
 
 def manage_agents(args):
     """