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

claude_mpm/agents/templates/circuit-breakers.md

@@ -523,23 +523,25 @@ PM: Task(agent="qa", task="Verify bug fix with regression test")
 
 ### KEY PRINCIPLE
 
-PM delegates implementation work, then MAY verify results.
+PM delegates ALL work - implementation AND verification.
 
 **Workflow:**
-1. **DELEGATE** to agent (using Task tool)
+1. **DELEGATE** implementation to appropriate agent (using Task tool)
 2. **WAIT** for agent to complete work
-3. **VERIFY** results (using Bash verification commands OR delegating verification)
-4. **REPORT** verified results with evidence
+3. **DELEGATE** verification to appropriate agent (local-ops, QA, web-qa)
+4. **REPORT** verified results with evidence from verification agent
 
-### Allowed Verification Commands (AFTER Delegation)
+### PM NEVER Uses Verification Commands
 
-These commands are ALLOWED for quality assurance AFTER delegating implementation:
+**FORBIDDEN for PM** (must delegate to local-ops or QA):
 
-- `curl`, `wget` - HTTP endpoint testing
-- `lsof`, `netstat`, `ss` - Port and network checks
-- `ps`, `pgrep` - Process status checks
-- `pm2 status`, `docker ps` - Service status
-- Health check endpoints
+- `curl`, `wget` - HTTP endpoint testing → Delegate to api-qa or local-ops
+- `lsof`, `netstat`, `ss` - Port and network checks → Delegate to local-ops
+- `ps`, `pgrep` - Process status checks → Delegate to local-ops
+- `pm2 status`, `docker ps` - Service status → Delegate to local-ops
+- Health check endpoints → Delegate to api-qa or web-qa
+
+**Why PM doesn't verify**: Verification is technical work requiring domain expertise. local-ops and QA agents have the tools, context, and expertise to verify correctly.
 
 ### Examples
 
@@ -550,23 +552,29 @@ These commands are ALLOWED for quality assurance AFTER delegating implementation
 PM: Bash("npm start")                       # VIOLATION - implementing
 PM: "App running on localhost:3000"         # VIOLATION - no delegation
 
+# Wrong: PM using verification commands
+PM: Bash("lsof -i :3000")                   # VIOLATION - should delegate to local-ops
+PM: Bash("curl http://localhost:3000")      # VIOLATION - should delegate to api-qa
+
 # Wrong: PM testing before delegating implementation
 PM: Bash("npm test")                        # VIOLATION - testing without implementation
 
 # Wrong: "Let me" thinking
 PM: "Let me check the code..."              # VIOLATION - should delegate
 PM: "Let me fix this bug..."                # VIOLATION - should delegate
+PM: "Let me verify the deployment..."       # VIOLATION - should delegate to local-ops
 ```
 
 #### ✅ CORRECT Examples
 
 ```
-# Correct: Delegate first, then verify
-PM: Task(agent="local-ops-agent", task="Start app on localhost:3000 using npm")
-    [Agent starts app]
-PM: Bash("lsof -i :3000 | grep LISTEN")     # ✅ ALLOWED - verifying after delegation
-PM: Bash("curl http://localhost:3000")      # ✅ ALLOWED - confirming deployment
-PM: "App verified: Port 3000 listening, HTTP 200 response"
+# Correct: Delegate implementation, then delegate verification
+PM: Task(agent="local-ops", task="Start app on localhost:3000 using npm")
+    [local-ops starts app]
+PM: Task(agent="local-ops", task="Verify app is running on port 3000")
+    [local-ops uses lsof and curl to verify]
+    [local-ops returns: "Port 3000 listening, HTTP 200 response"]
+PM: "App verified by local-ops: Port 3000 listening, HTTP 200 response"
 
 # Correct: Delegate implementation, then delegate testing
 PM: Task(agent="engineer", task="Fix authentication bug")
@@ -578,6 +586,7 @@ PM: "Bug fix verified by QA: All tests passed"
 # Correct: Thinking in delegation terms
 PM: "I'll have Research check the code..."
 PM: "I'll delegate this fix to Engineer..."
+PM: "I'll have local-ops verify the deployment..."
 ```
 
 ---

claude_mpm/cli/__init__.py

@@ -91,7 +91,11 @@ def main(argv: Optional[list] = None):
         )
 
         try:
-            run_background_services()
+            # Check for --force-sync flag or environment variable
+            force_sync = getattr(args, "force_sync", False) or os.environ.get(
+                "CLAUDE_MPM_FORCE_SYNC", "0"
+            ) in ("1", "true", "True", "yes")
+            run_background_services(force_sync=force_sync)
             launch_progress.finish(message="Ready")
 
             # Inform user about Claude Code initialization delay (3-5 seconds)

claude_mpm/cli/commands/agents.py

@@ -1379,7 +1379,7 @@ class AgentsCommand(AgentCommand):
                 return CommandResult.error_result("agent_id is required")
 
             import os
-            import subprocess
+            import subprocess  # nosec B404
 
             from ...services.agents.local_template_manager import (
                 LocalAgentTemplateManager,
@@ -1415,7 +1415,7 @@ class AgentsCommand(AgentCommand):
 
             # Use system editor
             editor = getattr(args, "editor", None) or os.environ.get("EDITOR", "nano")
-            subprocess.run([editor, str(template_file)], check=True)
+            subprocess.run([editor, str(template_file)], check=True)  # nosec B603
             return CommandResult.success_result(
                 f"Agent '{agent_id}' edited successfully"
             )
@@ -1519,8 +1519,6 @@ class AgentsCommand(AgentCommand):
             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")

claude_mpm/cli/commands/agents_reconcile.py

@@ -0,0 +1,197 @@
+"""
+Agent/Skill Reconciliation CLI Command
+
+Shows the reconciliation view between configured and deployed agents/skills,
+and performs reconciliation (deploy missing, remove unneeded).
+
+Usage:
+    claude-mpm agents reconcile [--dry-run] [--show-only]
+    claude-mpm skills reconcile [--dry-run] [--show-only]
+"""
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from ...core.unified_config import UnifiedConfig
+from ...services.agents.deployment.deployment_reconciler import (
+    DeploymentReconciler,
+    ReconciliationState,
+)
+from ..shared import BaseCommand, CommandResult
+
+
+class AgentsReconcileCommand(BaseCommand):
+    """CLI command for agent reconciliation."""
+
+    def __init__(self):
+        super().__init__("agents-reconcile")
+        self.console = Console()
+
+    def run(self, args) -> CommandResult:
+        """Execute reconciliation."""
+        # Load config
+        config = UnifiedConfig()
+        reconciler = DeploymentReconciler(config)
+
+        # Get project path
+        project_path = Path(getattr(args, "project_path", "."))
+
+        # Show current state
+        if getattr(args, "show_only", False) or getattr(args, "dry_run", False):
+            return self._show_reconciliation_view(reconciler, project_path)
+
+        # Perform reconciliation
+        return self._reconcile_agents(reconciler, project_path)
+
+    def _show_reconciliation_view(
+        self, reconciler: DeploymentReconciler, project_path: Path
+    ) -> CommandResult:
+        """Show reconciliation view without making changes."""
+        view = reconciler.get_reconciliation_view(project_path)
+        agent_state = view["agents"]
+        skill_state = view["skills"]
+
+        # Display agents table
+        self.console.print(
+            "\n[bold blue]═══ Agent Reconciliation View ═══[/bold blue]\n"
+        )
+        agent_table = self._build_reconciliation_table(agent_state, "Agent")
+        self.console.print(agent_table)
+
+        # Display skills table
+        self.console.print(
+            "\n[bold blue]═══ Skill Reconciliation View ═══[/bold blue]\n"
+        )
+        skill_table = self._build_reconciliation_table(skill_state, "Skill")
+        self.console.print(skill_table)
+
+        # Show summary
+        self._show_summary(agent_state, skill_state)
+
+        return CommandResult.success_result("Reconciliation view displayed")
+
+    def _build_reconciliation_table(
+        self, state: ReconciliationState, item_type: str
+    ) -> Table:
+        """Build Rich table for reconciliation state."""
+        table = Table(title=f"{item_type} Deployment Status")
+
+        table.add_column(f"{item_type}", style="cyan", no_wrap=True)
+        table.add_column("Configured", style="green")
+        table.add_column("Deployed", style="yellow")
+        table.add_column("Action", style="magenta")
+
+        # All items to consider
+        all_items = state.configured | state.deployed | state.cached
+
+        for item_id in sorted(all_items):
+            configured = "✓" if item_id in state.configured else "✗"
+            deployed = "✓" if item_id in state.deployed else "✗"
+
+            # Determine action
+            if item_id in state.to_deploy:
+                if item_id in state.cached:
+                    action = "Will deploy"
+                else:
+                    action = "[red]Missing in cache![/red]"
+            elif item_id in state.to_remove:
+                action = "Will remove"
+            elif item_id in state.unchanged:
+                action = "-"
+            elif item_id in state.cached and item_id not in state.configured:
+                action = "[dim]Available (not configured)[/dim]"
+            else:
+                action = "-"
+
+            table.add_row(item_id, configured, deployed, action)
+
+        return table
+
+    def _show_summary(
+        self, agent_state: ReconciliationState, skill_state: ReconciliationState
+    ) -> None:
+        """Show reconciliation summary."""
+        self.console.print("\n[bold]Summary:[/bold]")
+
+        # Agents
+        self.console.print("\nAgents:")
+        self.console.print(f"  Configured: {len(agent_state.configured)}")
+        self.console.print(f"  Deployed: {len(agent_state.deployed)}")
+        self.console.print(f"  To deploy: {len(agent_state.to_deploy)}")
+        self.console.print(f"  To remove: {len(agent_state.to_remove)}")
+        self.console.print(f"  Unchanged: {len(agent_state.unchanged)}")
+
+        # Skills
+        self.console.print("\nSkills:")
+        self.console.print(f"  Configured: {len(skill_state.configured)}")
+        self.console.print(f"  Deployed: {len(skill_state.deployed)}")
+        self.console.print(f"  To deploy: {len(skill_state.to_deploy)}")
+        self.console.print(f"  To remove: {len(skill_state.to_remove)}")
+        self.console.print(f"  Unchanged: {len(skill_state.unchanged)}")
+
+        # Show next steps
+        if agent_state.to_deploy or skill_state.to_deploy:
+            self.console.print(
+                "\n[yellow]Run without --show-only to perform deployment[/yellow]"
+            )
+
+    def _reconcile_agents(
+        self, reconciler: DeploymentReconciler, project_path: Path
+    ) -> CommandResult:
+        """Perform agent and skill reconciliation."""
+        # Show current state first
+        self._show_reconciliation_view(reconciler, project_path)
+
+        self.console.print("\n[bold blue]Performing reconciliation...[/bold blue]\n")
+
+        # Reconcile agents
+        self.console.print("[cyan]Reconciling agents...[/cyan]")
+        agent_result = reconciler.reconcile_agents(project_path)
+
+        if agent_result.deployed:
+            self.console.print(
+                f"  [green]✓ Deployed: {', '.join(agent_result.deployed)}[/green]"
+            )
+        if agent_result.removed:
+            self.console.print(
+                f"  [yellow]✓ Removed: {', '.join(agent_result.removed)}[/yellow]"
+            )
+        if agent_result.errors:
+            for error in agent_result.errors:
+                self.console.print(f"  [red]✗ {error}[/red]")
+
+        # Reconcile skills
+        self.console.print("\n[cyan]Reconciling skills...[/cyan]")
+        skill_result = reconciler.reconcile_skills(project_path)
+
+        if skill_result.deployed:
+            self.console.print(
+                f"  [green]✓ Deployed: {', '.join(skill_result.deployed)}[/green]"
+            )
+        if skill_result.removed:
+            self.console.print(
+                f"  [yellow]✓ Removed: {', '.join(skill_result.removed)}[/yellow]"
+            )
+        if skill_result.errors:
+            for error in skill_result.errors:
+                self.console.print(f"  [red]✗ {error}[/red]")
+
+        # Final summary
+        total_errors = len(agent_result.errors) + len(skill_result.errors)
+        if total_errors == 0:
+            self.console.print("\n[bold green]✓ Reconciliation complete![/bold green]")
+            return CommandResult.success_result("Reconciliation successful")
+        self.console.print(
+            f"\n[bold yellow]⚠ Reconciliation complete with {total_errors} errors[/bold yellow]"
+        )
+        return CommandResult.error_result(f"Reconciliation had {total_errors} errors")
+
+
+class SkillsReconcileCommand(AgentsReconcileCommand):
+    """CLI command for skill reconciliation (alias to agents reconcile)."""
+
+    def __init__(self):
+        BaseCommand.__init__(self, "skills-reconcile")
+        self.console = Console()