claude-mpm 5.4.22__py3-none-any.whl → 5.4.48__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -135,8 +135,8 @@ class AgentTemplateBuilder:
                 break
 
             # Stop at common repository root indicators (check AFTER finding BASE-AGENT.md)
-            # This ensures we check the 'agents' directory before stopping at 'remote-agents'
-            if current_dir.name in [".claude-mpm", "remote-agents", "cache"]:
+            # Stop at cache root or .claude-mpm directory
+            if current_dir.name in [".claude-mpm", "cache"]:
                 self.logger.debug(
                     f"Reached repository root indicator at: {current_dir}"
                 )
@@ -419,7 +419,7 @@ class AgentTemplateBuilder:
         if non_standard:
             self.logger.info(f"Using non-standard tools: {non_standard}")
 
-        # Extract model from template with fallback
+        # Extract model from template (no fallback - preserve None if not specified)
         capabilities_model = (
             capabilities.get("model") if isinstance(capabilities, dict) else None
         )
@@ -428,7 +428,7 @@ class AgentTemplateBuilder:
             template_data.get("model")
             or capabilities_model
             or template_data.get("configuration_fields", {}).get("model")
-            or "sonnet"  # Default fallback
+            # No default fallback - preserve None if not set
         )
 
         # Convert tools list to comma-separated string (without spaces for compatibility)
@@ -448,11 +448,11 @@ class AgentTemplateBuilder:
             "opus": "opus",
         }
 
-        if model in model_map:
-            model = model_map[model]
-        else:
-            # Default to sonnet if model not found in map
-            model = "sonnet"
+        # Only map model if it's not None
+        if model is not None:
+            if model in model_map:
+                model = model_map[model]
+            # If model is specified but not in map, keep as-is (no default)
 
         # Get response format from template or use base agent default
         template_data.get("response", {}).get("format", "structured")
@@ -559,8 +559,9 @@ class AgentTemplateBuilder:
             f"description: {self._format_description_for_yaml(description)}"
         )
 
-        # Add model field (required for Claude Code)
-        frontmatter_lines.append(f"model: {model}")
+        # Add model field only if explicitly set (not required for Claude Code)
+        if model is not None:
+            frontmatter_lines.append(f"model: {model}")
 
         # Add type field (important for agent categorization)
         if agent_type and agent_type != "general":
@@ -718,21 +719,30 @@ Only include memories that are:
             "description", f"{name} agent for specialized tasks"
         )
 
-        # Get tools and model with fallbacks
+        # Get tools and model (no fallback for model)
         raw_tools = merged_config.get("tools")
         tools = self.normalize_tools_input(raw_tools)
-        model = merged_config.get("model", "sonnet")
+        model = merged_config.get("model")  # No default - preserve None
 
         # Format tools as YAML list
         tools_yaml = self.format_yaml_list(tools, 2)
 
         # Build YAML content with only essential fields
-        return f"""name: {name}
-description: {description}
-model: {model}
-tools:
-{tools_yaml}
-"""
+        yaml_lines = [
+            f"name: {name}",
+            f"description: {description}",
+        ]
+
+        # Only include model if explicitly set
+        if model is not None:
+            yaml_lines.append(f"model: {model}")
+
+        yaml_lines.extend([
+            "tools:",
+            tools_yaml,
+        ])
+
+        return "\n".join(yaml_lines) + "\n"
 
     def merge_narrative_fields(self, base_data: dict, template_data: dict) -> dict:
         """

claude_mpm/services/agents/deployment/agents_directory_resolver.py

@@ -8,7 +8,7 @@ DEPLOYMENT ARCHITECTURE:
 
 Agent Source Locations (Discovery):
 -----------------------------------
-1. System Agents:  ~/.claude-mpm/cache/remote-agents/bobmatnyc/claude-mpm-agents/
+1. System Agents:  ~/.claude-mpm/cache/agents/bobmatnyc/claude-mpm-agents/
    - Synced from GitHub repository
    - Read-only (managed by git pull)
    - 44+ agents organized by category
@@ -39,7 +39,7 @@ Why Project-Level Deployment?
 Example Flow:
 -------------
 1. User runs: claude-mpm agents deploy
-2. Agents synced from GitHub → ~/.claude-mpm/cache/remote-agents/
+2. Agents synced from GitHub → ~/.claude-mpm/cache/agents/
 3. Agents deployed FROM cache → .claude/agents/
 4. Claude Code discovers agents FROM .claude/agents/
 

claude_mpm/services/agents/deployment/async_agent_deployment.py

@@ -551,38 +551,39 @@ class AsyncAgentDeploymentService:
             or ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
         )
 
-        # Get model from capabilities.model in new format
+        # Get model from capabilities.model in new format (no default fallback)
         model = (
             agent_data.get("capabilities", {}).get("model")
             or agent_data.get("configuration_fields", {}).get("model")
-            or "sonnet"  # Default fallback
+            # No default fallback - preserve None if not set
         )
 
-        # Simplify model name for Claude Code
-        model_map = {
-            "claude-4-sonnet-20250514": "sonnet",
-            "claude-sonnet-4-20250514": "sonnet",
-            "claude-opus-4-20250514": "opus",
-            "claude-3-opus-20240229": "opus",
-            "claude-3-haiku-20240307": "haiku",
-            "claude-3.5-sonnet": "sonnet",
-            "claude-3-sonnet": "sonnet",
-        }
-        # Better fallback: extract the model type (opus/sonnet/haiku) from the string
-        if model not in model_map:
-            if "opus" in model.lower():
-                model = "opus"
-            elif "sonnet" in model.lower():
-                model = "sonnet"
-            elif "haiku" in model.lower():
-                model = "haiku"
+        # Simplify model name for Claude Code (only if model is specified)
+        if model is not None:
+            model_map = {
+                "claude-4-sonnet-20250514": "sonnet",
+                "claude-sonnet-4-20250514": "sonnet",
+                "claude-opus-4-20250514": "opus",
+                "claude-3-opus-20240229": "opus",
+                "claude-3-haiku-20240307": "haiku",
+                "claude-3.5-sonnet": "sonnet",
+                "claude-3-sonnet": "sonnet",
+            }
+            # Better fallback: extract the model type (opus/sonnet/haiku) from the string
+            if model not in model_map:
+                if "opus" in model.lower():
+                    model = "opus"
+                elif "sonnet" in model.lower():
+                    model = "sonnet"
+                elif "haiku" in model.lower():
+                    model = "haiku"
+                else:
+                    # Last resort: try to extract from hyphenated format
+                    model = model_map.get(
+                        model, model.split("-")[-1] if "-" in model else model
+                    )
             else:
-                # Last resort: try to extract from hyphenated format
-                model = model_map.get(
-                    model, model.split("-")[-1] if "-" in model else model
-                )
-        else:
-            model = model_map[model]
+                model = model_map[model]
 
         # Convert tools list to comma-separated string for Claude Code compatibility
         # IMPORTANT: No spaces after commas - Claude Code requires exact format
@@ -601,9 +602,12 @@ class AsyncAgentDeploymentService:
             f"base_version: {self._format_version_display(base_version)}",
             "author: claude-mpm",  # Identify as system agent for deployment
             f"tools: {tools_str}",
-            f"model: {model}",
         ]
 
+        # Only include model field if explicitly set
+        if model is not None:
+            frontmatter_lines.append(f"model: {model}")
+
         # Add optional fields if present
         # Check for color in metadata section (new format) or root (old format)
         color = agent_data.get("metadata", {}).get("color") or agent_data.get("color")

claude_mpm/services/agents/deployment/local_template_deployment.py

@@ -157,7 +157,9 @@ class LocalTemplateDeploymentService:
 
         # Add capabilities
         if template.capabilities:
-            frontmatter["model"] = template.capabilities.get("model", "sonnet")
+            # Only include model if explicitly set (no default)
+            if "model" in template.capabilities:
+                frontmatter["model"] = template.capabilities["model"]
             tools = template.capabilities.get("tools", "*")
             if tools == "*":
                 frontmatter["tools"] = "all"

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -26,6 +26,18 @@ from .agent_version_manager import AgentVersionManager
 from .remote_agent_discovery_service import RemoteAgentDiscoveryService
 
 
+def _normalize_agent_name(name: str) -> str:
+    """Normalize agent name for consistent comparison.
+
+    Converts spaces, underscores to hyphens and lowercases.
+    Examples:
+        "Dart Engineer" -> "dart-engineer"
+        "dart_engineer" -> "dart-engineer"
+        "DART-ENGINEER" -> "dart-engineer"
+    """
+    return name.lower().replace(" ", "-").replace("_", "-")
+
+
 class MultiSourceAgentDeploymentService:
     """Service for deploying agents from multiple sources with version comparison.
 
@@ -179,14 +191,14 @@ class MultiSourceAgentDeploymentService:
         system_templates_dir: Optional[Path] = None,
         project_agents_dir: Optional[Path] = None,
         user_agents_dir: Optional[Path] = None,
-        remote_agents_dir: Optional[Path] = None,
+        agents_cache_dir: Optional[Path] = None,
         working_directory: Optional[Path] = None,
     ) -> Dict[str, List[Dict[str, Any]]]:
-        """Discover agents from all 4 tiers (system, user, remote, project).
+        """Discover agents from all 4 tiers (system, user, cache, project).
 
         Priority hierarchy (highest to lowest):
         4. Project agents - Highest priority, project-specific customizations
-        3. Remote agents - GitHub-synced agents from cache
+        3. Cached agents - GitHub-synced agents from cache
         2. User agents - DEPRECATED, user-level customizations
         1. System templates - Lowest priority, built-in agents
 
@@ -194,7 +206,7 @@ class MultiSourceAgentDeploymentService:
             system_templates_dir: Directory containing system agent templates
             project_agents_dir: Directory containing project-specific agents
             user_agents_dir: Directory containing user custom agents (DEPRECATED)
-            remote_agents_dir: Directory containing cached remote agents
+            agents_cache_dir: Directory containing cached agents from Git sources
             working_directory: Current working directory for finding project agents
 
         Returns:
@@ -225,12 +237,12 @@ class MultiSourceAgentDeploymentService:
             if not user_agents_dir.exists():
                 user_agents_dir = None
 
-        if not remote_agents_dir:
-            # Check for remote agents in cache directory
+        if not agents_cache_dir:
+            # Check for agents in cache directory
             cache_dir = Path.home() / ".claude-mpm" / "cache"
-            remote_agents_dir = cache_dir / "remote-agents"
-            if not remote_agents_dir.exists():
-                remote_agents_dir = None
+            agents_cache_dir = cache_dir / "agents"
+            if not agents_cache_dir.exists():
+                agents_cache_dir = None
 
         # Discover agents from each source in priority order
         # Note: We process in reverse priority order (system first) and build up the dictionary
@@ -238,7 +250,7 @@ class MultiSourceAgentDeploymentService:
         sources = [
             ("system", system_templates_dir),
             ("user", user_agents_dir),
-            ("remote", remote_agents_dir),
+            ("remote", agents_cache_dir),
             ("project", project_agents_dir),
         ]
 
@@ -323,7 +335,7 @@ class MultiSourceAgentDeploymentService:
     def get_agents_by_collection(
         self,
         collection_id: str,
-        remote_agents_dir: Optional[Path] = None,
+        agents_cache_dir: Optional[Path] = None,
     ) -> List[Dict[str, Any]]:
         """Get all agents from a specific collection.
 
@@ -331,7 +343,7 @@ class MultiSourceAgentDeploymentService:
 
         Args:
             collection_id: Collection identifier (e.g., "bobmatnyc/claude-mpm-agents")
-            remote_agents_dir: Directory containing remote agents cache
+            agents_cache_dir: Directory containing agents cache
 
         Returns:
             List of agent dictionaries from the specified collection
@@ -342,18 +354,16 @@ class MultiSourceAgentDeploymentService:
             >>> len(agents)
             45
         """
-        if not remote_agents_dir:
+        if not agents_cache_dir:
             cache_dir = Path.home() / ".claude-mpm" / "cache"
-            remote_agents_dir = cache_dir / "remote-agents"
+            agents_cache_dir = cache_dir / "agents"
 
-        if not remote_agents_dir.exists():
-            self.logger.warning(
-                f"Remote agents directory not found: {remote_agents_dir}"
-            )
+        if not agents_cache_dir.exists():
+            self.logger.warning(f"Agents cache directory not found: {agents_cache_dir}")
             return []
 
         # Use RemoteAgentDiscoveryService to get collection agents
-        remote_service = RemoteAgentDiscoveryService(remote_agents_dir)
+        remote_service = RemoteAgentDiscoveryService(agents_cache_dir)
         collection_agents = remote_service.get_agents_by_collection(collection_id)
 
         self.logger.info(
@@ -470,7 +480,7 @@ class MultiSourceAgentDeploymentService:
         system_templates_dir: Optional[Path] = None,
         project_agents_dir: Optional[Path] = None,
         user_agents_dir: Optional[Path] = None,
-        remote_agents_dir: Optional[Path] = None,
+        agents_cache_dir: Optional[Path] = None,
         working_directory: Optional[Path] = None,
         excluded_agents: Optional[List[str]] = None,
         config: Optional[Config] = None,
@@ -482,7 +492,7 @@ class MultiSourceAgentDeploymentService:
             system_templates_dir: Directory containing system agent templates
             project_agents_dir: Directory containing project-specific agents
             user_agents_dir: Directory containing user custom agents (DEPRECATED)
-            remote_agents_dir: Directory containing cached remote agents
+            agents_cache_dir: Directory containing cached agents from Git sources
             working_directory: Current working directory for finding project agents
             excluded_agents: List of agent names to exclude from deployment
             config: Configuration object for additional filtering
@@ -499,7 +509,7 @@ class MultiSourceAgentDeploymentService:
             system_templates_dir=system_templates_dir,
             project_agents_dir=project_agents_dir,
             user_agents_dir=user_agents_dir,
-            remote_agents_dir=remote_agents_dir,
+            agents_cache_dir=agents_cache_dir,
             working_directory=working_directory,
         )
 
@@ -533,10 +543,44 @@ class MultiSourceAgentDeploymentService:
 
         # Apply exclusion filters
         if excluded_agents:
-            for agent_name in excluded_agents:
-                if agent_name in selected_agents:
-                    self.logger.info(f"Excluding agent '{agent_name}' from deployment")
-                    del selected_agents[agent_name]
+            # Find agents to remove by matching normalized names
+            # Normalization handles: "Dart Engineer", "dart_engineer", "dart-engineer"
+            agents_to_remove = []
+            excluded_set = {_normalize_agent_name(name) for name in excluded_agents}
+
+            for canonical_id, agent_info in list(selected_agents.items()):
+                # Check agent name field (normalized)
+                agent_name = _normalize_agent_name(agent_info.get("name", ""))
+
+                # Also check the agent_id portion of canonical_id (after the colon)
+                # Example: "bobmatnyc/claude-mpm-agents:pm" -> "pm"
+                raw_agent_id = (
+                    canonical_id.split(":")[-1]
+                    if ":" in canonical_id
+                    else canonical_id
+                )
+                agent_id = _normalize_agent_name(raw_agent_id)
+
+                # Check file stem from path (most reliable match)
+                file_stem = ""
+                path_str = agent_info.get("path") or agent_info.get("file_path")
+                if path_str:
+                    file_stem = _normalize_agent_name(Path(path_str).stem)
+
+                if (
+                    agent_name in excluded_set
+                    or agent_id in excluded_set
+                    or file_stem in excluded_set
+                ):
+                    agents_to_remove.append(canonical_id)
+                    self.logger.info(
+                        f"Excluding agent '{agent_info.get('name', raw_agent_id)}' "
+                        f"(canonical_id: {canonical_id}) from deployment"
+                    )
+
+            # Remove matched agents
+            for canonical_id in agents_to_remove:
+                del selected_agents[canonical_id]
 
         # Apply config-based filtering if provided
         if config:
@@ -585,6 +629,105 @@ class MultiSourceAgentDeploymentService:
 
         return agents_to_deploy, agent_sources, cleanup_results
 
+    def cleanup_excluded_agents(
+        self,
+        deployed_agents_dir: Path,
+        agents_to_deploy: Dict[str, Path],
+    ) -> Dict[str, Any]:
+        """Remove agents from deployed directory that aren't in the deployment list.
+
+        Similar to skill cleanup logic, this removes agents that were previously
+        deployed but are no longer in the enabled agents list (e.g., filtered out
+        by profile configuration).
+
+        Args:
+            deployed_agents_dir: Directory containing deployed agents (~/.claude/agents)
+            agents_to_deploy: Dictionary mapping agent file stems to template paths
+
+        Returns:
+            Dictionary with cleanup results:
+            - removed: List of removed agent names
+            - errors: List of errors during cleanup
+        """
+        cleanup_results = {"removed": [], "errors": []}
+
+        # Safety check - only operate on deployed agents directory
+        if not deployed_agents_dir.exists():
+            self.logger.debug("Deployed agents directory does not exist, no cleanup needed")
+            return cleanup_results
+
+        # Build set of agent names that should exist (file stems without .md extension)
+        expected_agents = set(agents_to_deploy.keys())
+
+        try:
+            # Check each file in deployed_agents_dir
+            for item in deployed_agents_dir.iterdir():
+                # Only process .md files
+                if not item.is_file() or item.suffix != ".md":
+                    continue
+
+                # Skip hidden files
+                if item.name.startswith("."):
+                    continue
+
+                # Get agent name (file stem)
+                agent_name = item.stem
+
+                # Check if this agent should be kept
+                if agent_name not in expected_agents:
+                    try:
+                        # Security: Validate path is within deployed_agents_dir
+                        resolved_item = item.resolve()
+                        resolved_target = deployed_agents_dir.resolve()
+
+                        if not str(resolved_item).startswith(str(resolved_target)):
+                            self.logger.error(
+                                f"Refusing to remove path outside target directory: {item}"
+                            )
+                            cleanup_results["errors"].append(
+                                {
+                                    "agent": agent_name,
+                                    "error": "Path outside target directory",
+                                }
+                            )
+                            continue
+
+                        # Remove the agent file
+                        item.unlink()
+                        cleanup_results["removed"].append(agent_name)
+                        self.logger.info(f"Removed excluded agent: {agent_name}")
+
+                    except PermissionError as e:
+                        error_msg = f"Permission denied removing {agent_name}: {e}"
+                        self.logger.error(error_msg)
+                        cleanup_results["errors"].append(
+                            {"agent": agent_name, "error": error_msg}
+                        )
+                    except Exception as e:
+                        error_msg = f"Error removing {agent_name}: {e}"
+                        self.logger.error(error_msg)
+                        cleanup_results["errors"].append(
+                            {"agent": agent_name, "error": error_msg}
+                        )
+
+        except Exception as e:
+            self.logger.error(f"Error during agent cleanup: {e}")
+            cleanup_results["errors"].append(
+                {"agent": "cleanup_process", "error": str(e)}
+            )
+
+        # Log cleanup summary
+        if cleanup_results["removed"]:
+            self.logger.info(
+                f"Cleanup complete: removed {len(cleanup_results['removed'])} excluded agents"
+            )
+        if cleanup_results["errors"]:
+            self.logger.warning(
+                f"Encountered {len(cleanup_results['errors'])} errors during cleanup"
+            )
+
+        return cleanup_results
+
     def cleanup_outdated_user_agents(
         self,
         agents_by_name: Dict[str, List[Dict[str, Any]]],