claude-mpm 5.4.36__py3-none-any.whl → 5.4.59__py3-none-any.whl

claude_mpm/services/agents/agent_builder.py

@@ -206,8 +206,8 @@ class AgentBuilderService:
         """
         errors = []
 
-        # Required fields
-        required_fields = ["id", "name", "prompt", "model"]
+        # Required fields (model is optional - defaults to sonnet if not specified)
+        required_fields = ["id", "name", "prompt"]
         for field in required_fields:
             if field not in config:
                 errors.append(f"Missing required field: {field}")
@@ -219,7 +219,7 @@ class AgentBuilderService:
             except AgentDeploymentError as e:
                 errors.append(str(e))
 
-        # Validate model
+        # Validate model (only if present)
         if "model" in config:
             try:
                 self._validate_model(config["model"])

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -898,6 +898,9 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
             )
         )
 
+        # Keep track of all enabled agents before filtering (for cleanup)
+        all_enabled_agents = agents_to_deploy.copy()
+
         # Compare with deployed versions if agents directory exists
         if agents_dir.exists():
             comparison_results = self.multi_source_service.compare_deployed_versions(
@@ -954,6 +957,25 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                         f"All {len(comparison_results.get('up_to_date', []))} agents are up to date"
                     )
 
+        # Cleanup excluded agents (remove agents not in deployment list)
+        # CRITICAL: Use all_enabled_agents (before filtering for updates) to preserve up-to-date agents
+        # Bug fix (1M-XXX): Previously used filtered agents_to_deploy which could be empty,
+        # causing all agents to be removed when everything was up-to-date
+        exclusion_cleanup_results = self.multi_source_service.cleanup_excluded_agents(
+            deployed_agents_dir=agents_dir,
+            agents_to_deploy=all_enabled_agents,
+        )
+
+        # Add exclusion cleanup results to main cleanup results
+        if exclusion_cleanup_results.get("removed"):
+            cleanup_results.setdefault("excluded_removed", []).extend(
+                exclusion_cleanup_results["removed"]
+            )
+            self.logger.info(
+                f"Removed {len(exclusion_cleanup_results['removed'])} excluded agents: "
+                f"{', '.join(exclusion_cleanup_results['removed'])}"
+            )
+
         # Convert to list of Path objects
         template_files = list(agents_to_deploy.values())
 

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -248,7 +248,9 @@ class AgentDiscoveryService:
             return agent_info
 
         except yaml.YAMLError as e:
-            self.logger.warning(f"Invalid YAML frontmatter in {template_file.name}: {e}")
+            self.logger.warning(
+                f"Invalid YAML frontmatter in {template_file.name}: {e}"
+            )
             return None
         except Exception as e:
             self.logger.error(

claude_mpm/services/agents/deployment/agent_format_converter.py

@@ -137,8 +137,8 @@ class AgentFormatConverter:
         else:
             pass
 
-        # Extract additional fields
-        model = self.extract_yaml_field(yaml_content, "model") or "sonnet"
+        # Extract additional fields - model is optional (Claude Code uses conversation model if not set)
+        model = self.extract_yaml_field(yaml_content, "model")  # None if not specified
         author = (
             self.extract_yaml_field(yaml_content, "author")
             or "claude-mpm@anthropic.com"
@@ -147,7 +147,7 @@ class AgentFormatConverter:
         # Extract instructions from YAML content
         instructions = self._extract_instructions_from_yaml(yaml_content, agent_name)
 
-        # Map model names to Claude Code format
+        # Map model names to Claude Code format (only if model is specified)
         model_map = {
             "claude-3-5-sonnet-20241022": "sonnet",
             "claude-3-5-sonnet": "sonnet",
@@ -159,7 +159,8 @@ class AgentFormatConverter:
             "opus": "opus",
         }
 
-        mapped_model = model_map.get(model, "sonnet")
+        # Only map model if it's not None (preserve None for agents without model field)
+        mapped_model = model_map.get(model, model) if model is not None else None
 
         # Create multiline description with example (Claude Code format)
         multiline_description = f"""{description}
@@ -172,16 +173,27 @@ assistant: "I'll use the {name} agent to provide specialized assistance."
 
         # Build new YAML frontmatter - Claude Code compatible format
         # NOTE: Removed tags field and other non-essential fields for Claude Code compatibility
-        new_frontmatter = f"""---
-name: {name}
-description: |
-  {self._indent_text(multiline_description, 2)}
-model: {mapped_model}
-version: "{version}"
-author: "{author}"
----
+        frontmatter_lines = [
+            "---",
+            f"name: {name}",
+            "description: |",
+            f"  {self._indent_text(multiline_description, 2)}",
+        ]
 
-"""
+        # Only include model field if explicitly set in source
+        if mapped_model is not None:
+            frontmatter_lines.append(f"model: {mapped_model}")
+
+        frontmatter_lines.extend(
+            [
+                f'version: "{version}"',
+                f'author: "{author}"',
+                "---",
+                "",
+            ]
+        )
+
+        new_frontmatter = "\n".join(frontmatter_lines)
 
         return new_frontmatter + instructions
 

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -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,32 @@ 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/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.
 
@@ -531,10 +543,42 @@ 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:
@@ -583,6 +627,107 @@ 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]]],

claude_mpm/services/agents/deployment/remote_agent_discovery_service.py

@@ -402,10 +402,11 @@ class RemoteAgentDiscoveryService:
             )
             return agents
 
-        # Support three cache structures (PRIORITY ORDER):
+        # Support four cache structures (PRIORITY ORDER):
         # 1. Built output: {path}/dist/agents/ - PREFERRED (built with BASE-AGENT composition)
         # 2. Git repo path: {path}/agents/ - source files (fallback)
-        # 3. Flattened cache: {path}/ - directly contains category directories (legacy)
+        # 3. Owner/repo structure: {path}/{owner}/{repo}/agents/ - GitHub sync structure
+        # 4. Flattened cache: {path}/ - directly contains category directories (legacy)
 
         # Priority 1: Check for dist/agents/ (built output with BASE-AGENT composition)
         dist_agents_dir = self.agents_cache_dir / "dist" / "agents"
@@ -422,32 +423,52 @@ class RemoteAgentDiscoveryService:
             self.logger.debug(f"Using source agents (no dist/ found): {agents_dir}")
             scan_dir = agents_dir
         else:
-            # LEGACY: Flattened cache structure - scan root directly
-            # Check if this looks like the flattened cache (has category subdirectories)
-            category_dirs = [
-                "universal",
-                "engineer",
-                "ops",
-                "qa",
-                "security",
-                "documentation",
-            ]
-            has_categories = any(
-                (self.agents_cache_dir / cat).exists() for cat in category_dirs
-            )
-
-            if has_categories:
-                self.logger.debug(
-                    f"Using flattened cache structure: {self.agents_cache_dir}"
-                )
-                scan_dir = self.agents_cache_dir
+            # Priority 3: Check for {owner}/{repo}/agents/ structure (GitHub sync)
+            # e.g., ~/.claude-mpm/cache/agents/bobmatnyc/claude-mpm-agents/agents/
+            owner_repo_agents_dir = None
+            for owner_dir in self.agents_cache_dir.iterdir():
+                if owner_dir.is_dir() and not owner_dir.name.startswith("."):
+                    for repo_dir in owner_dir.iterdir():
+                        if repo_dir.is_dir():
+                            potential_agents = repo_dir / "agents"
+                            if potential_agents.exists():
+                                owner_repo_agents_dir = potential_agents
+                                self.logger.debug(
+                                    f"Using GitHub sync structure: {owner_repo_agents_dir}"
+                                )
+                                break
+                    if owner_repo_agents_dir:
+                        break
+
+            if owner_repo_agents_dir:
+                scan_dir = owner_repo_agents_dir
             else:
-                self.logger.warning(
-                    f"No agent directories found. Checked: {dist_agents_dir}, {agents_dir}, "
-                    f"and category directories in {self.agents_cache_dir}. "
-                    f"Expected agents in /dist/agents/, /agents/, or category directories."
+                # LEGACY: Flattened cache structure - scan root directly
+                # Check if this looks like the flattened cache (has category subdirectories)
+                category_dirs = [
+                    "universal",
+                    "engineer",
+                    "ops",
+                    "qa",
+                    "security",
+                    "documentation",
+                ]
+                has_categories = any(
+                    (self.agents_cache_dir / cat).exists() for cat in category_dirs
                 )
-                return agents
+
+                if has_categories:
+                    self.logger.debug(
+                        f"Using flattened cache structure: {self.agents_cache_dir}"
+                    )
+                    scan_dir = self.agents_cache_dir
+                else:
+                    self.logger.warning(
+                        f"No agent directories found. Checked: {dist_agents_dir}, {agents_dir}, "
+                        f"owner/repo/agents/ structure, and category directories in {self.agents_cache_dir}. "
+                        "Expected agents in /dist/agents/, /agents/, owner/repo/agents/, or category directories."
+                    )
+                    return agents
 
         # Find all Markdown files recursively
         md_files = list(scan_dir.rglob("*.md"))

claude_mpm/services/agents/git_source_manager.py

@@ -395,8 +395,27 @@ class GitSourceManager:
                     )
                     logger.debug(f"[DEBUG] Found {len(agents)} agents so far")
 
-        logger.debug(f"[DEBUG] list_cached_agents COMPLETE: {len(agents)} total agents")
-        return agents
+        logger.debug(
+            f"[DEBUG] list_cached_agents COMPLETE: {len(agents)} total agents (before deduplication)"
+        )
+
+        # Deduplicate agents by agent_id (Bug #2 fix)
+        # When same agent exists in multiple locations, keep only first occurrence
+        seen_ids = set()
+        deduplicated_agents = []
+
+        for agent in agents:
+            agent_id = agent.get("agent_id") or agent.get("metadata", {}).get("name")
+            if agent_id and agent_id not in seen_ids:
+                seen_ids.add(agent_id)
+                deduplicated_agents.append(agent)
+            elif agent_id:
+                logger.debug(f"[DEBUG] Skipping duplicate agent: {agent_id}")
+
+        logger.debug(
+            f"[DEBUG] After deduplication: {len(deduplicated_agents)} unique agents"
+        )
+        return deduplicated_agents
 
     def _discover_agents_in_directory(
         self,