claude-mpm 3.5.2__py3-none-any.whl → 3.5.6__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -70,13 +70,14 @@ class AgentDeploymentService:
     - YAML generation capabilities
     """
     
-    def __init__(self, templates_dir: Optional[Path] = None, base_agent_path: Optional[Path] = None):
+    def __init__(self, templates_dir: Optional[Path] = None, base_agent_path: Optional[Path] = None, working_directory: Optional[Path] = None):
         """
         Initialize agent deployment service.
         
         Args:
-            templates_dir: Directory containing agent template files
+            templates_dir: Directory containing agent JSON files
             base_agent_path: Path to base_agent.md file
+            working_directory: User's working directory (for project agents)
             
         METRICS OPPORTUNITY: Track initialization performance:
         - Template directory scan time
@@ -100,11 +101,24 @@ class AgentDeploymentService:
             'deployment_errors': {}  # Track error types and frequencies
         }
         
+        # Determine the actual working directory
+        # Priority: working_directory param > CLAUDE_MPM_USER_PWD env var > current directory
+        if working_directory:
+            self.working_directory = Path(working_directory)
+        elif 'CLAUDE_MPM_USER_PWD' in os.environ:
+            self.working_directory = Path(os.environ['CLAUDE_MPM_USER_PWD'])
+        else:
+            self.working_directory = Path.cwd()
+        
+        self.logger.info(f"Working directory for deployment: {self.working_directory}")
+        
         # Find templates directory using centralized path management
         if templates_dir:
             self.templates_dir = Path(templates_dir)
         else:
             # Use centralized paths instead of fragile parent calculations
+            # For system agents, still use templates subdirectory
+            # For project/user agents, this should be overridden with actual agents dir
             self.templates_dir = paths.agents_dir / "templates"
         
         # Find base agent file
@@ -135,6 +149,7 @@ class AgentDeploymentService:
         - Error type frequencies
         
         OPERATIONAL FLOW:
+        0. Validates and repairs broken frontmatter in existing agents (Step 0)
         1. Validates target directory (creates if needed)
         2. Loads base agent configuration
         3. Discovers all agent templates
@@ -176,13 +191,15 @@ class AgentDeploymentService:
             - skipped: List of unchanged agents
             - errors: List of deployment errors
             - total: Total number of agents processed
+            - repaired: List of agents with repaired frontmatter
         """
         # METRICS: Record deployment start time for performance tracking
         deployment_start_time = time.time()
         
         if not target_dir:
-            # Default to user's home .claude/agents directory
-            agents_dir = Path(Paths.CLAUDE_AGENTS_DIR.value).expanduser()
+            # Default to working directory's .claude/agents directory (not home)
+            # This ensures we deploy to the user's project directory, not the framework directory
+            agents_dir = self.working_directory / ".claude" / "agents"
         else:
             # If target_dir provided, use it directly (caller decides structure)
             # This allows for both passing a project dir or the full agents path
@@ -209,6 +226,7 @@ class AgentDeploymentService:
             "updated": [],
             "migrated": [],  # Track agents migrated from old format
             "converted": [],  # Track YAML to MD conversions
+            "repaired": [],  # Track agents with repaired frontmatter
             "total": 0,
             # METRICS: Add detailed timing and performance data to results
             "metrics": {
@@ -224,13 +242,30 @@ class AgentDeploymentService:
         try:
             # Create agents directory if needed
             agents_dir.mkdir(parents=True, exist_ok=True)
-            self.logger.info(f"Building and deploying agents to: {agents_dir}")
+            
+            # STEP 0: Validate and repair broken frontmatter in existing agents
+            # This ensures all existing agents have valid YAML frontmatter before deploying new ones
+            repair_results = self._validate_and_repair_existing_agents(agents_dir)
+            if repair_results["repaired"]:
+                results["repaired"] = repair_results["repaired"]
+                self.logger.info(f"Repaired frontmatter in {len(repair_results['repaired'])} existing agents")
+                for agent_name in repair_results["repaired"]:
+                    self.logger.debug(f"  - Repaired: {agent_name}")
+            
+            # Determine source tier for logging
+            source_tier = "SYSTEM"
+            if ".claude-mpm/agents" in str(self.templates_dir) and "/templates" not in str(self.templates_dir):
+                source_tier = "PROJECT" 
+            elif "/.claude-mpm/agents" in str(self.templates_dir) and "/templates" not in str(self.templates_dir):
+                source_tier = "USER"
+            
+            self.logger.info(f"Building and deploying {source_tier} agents to: {agents_dir}")
             
             # Note: System instructions are now loaded directly by SimpleClaudeRunner
             
             # Check if templates directory exists
             if not self.templates_dir.exists():
-                error_msg = f"Templates directory not found: {self.templates_dir}"
+                error_msg = f"Agents directory not found: {self.templates_dir}"
                 self.logger.error(error_msg)
                 results["errors"].append(error_msg)
                 return results
@@ -260,7 +295,8 @@ class AgentDeploymentService:
             # Get all template files
             template_files = list(self.templates_dir.glob("*.json"))
             # Filter out non-agent files - exclude system files and uppercase special files
-            excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README"}
+            # CRITICAL: PM (Project Manager) must NEVER be deployed as it's the main Claude instance
+            excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README", "pm", "PM", "project_manager"}
             template_files = [
                 f for f in template_files 
                 if f.stem not in excluded_names 
@@ -364,6 +400,7 @@ class AgentDeploymentService:
                 f"updated {len(results['updated'])}, "
                 f"migrated {len(results['migrated'])}, "
                 f"converted {len(results['converted'])} YAML files, "
+                f"repaired {len(results['repaired'])} frontmatter, "
                 f"skipped {len(results['skipped'])}, "
                 f"errors: {len(results['errors'])}"
             )
@@ -568,20 +605,36 @@ class AgentDeploymentService:
         # Simplify model name for Claude Code
         model_map = {
             'claude-4-sonnet-20250514': 'sonnet',
-            'claude-sonnet-4-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'
         }
-        model = model_map.get(model, model.split('-')[-1] if '-' in model else model)
+        # 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:
+            model = model_map[model]
         
         # Get response format from template or use base agent default
         response_format = template_data.get('response', {}).get('format', 'structured')
         
         # Convert lists to space-separated strings for Claude Code compatibility
         tags_str = ' '.join(tags) if isinstance(tags, list) else tags
-        tools_str = ', '.join(tools) if isinstance(tools, list) else tools
+        
+        # Convert tools list to comma-separated string for Claude Code compatibility
+        # IMPORTANT: No spaces after commas - Claude Code requires exact format
+        tools_str = ','.join(tools) if isinstance(tools, list) else tools
         
         # Build frontmatter with only the fields Claude Code uses
         frontmatter_lines = [
@@ -596,8 +649,13 @@ class AgentDeploymentService:
         ]
         
         # Add optional fields if present
-        if template_data.get('color'):
-            frontmatter_lines.append(f"color: {template_data['color']}")
+        # Check for color in metadata section (new format) or root (old format)
+        color = (
+            template_data.get('metadata', {}).get('color') or
+            template_data.get('color')
+        )
+        if color:
+            frontmatter_lines.append(f"color: {color}")
         
         frontmatter_lines.append("---")
         frontmatter_lines.append("")
@@ -834,7 +892,8 @@ temperature: {temperature}"""
             Dictionary of environment variables set for verification
         """
         if not config_dir:
-            config_dir = Path.cwd() / Paths.CLAUDE_CONFIG_DIR.value
+            # Use the working directory determined during initialization
+            config_dir = self.working_directory / Paths.CLAUDE_CONFIG_DIR.value
         
         env_vars = {}
         
@@ -900,7 +959,8 @@ temperature: {temperature}"""
             - warnings: List of potential issues
         """
         if not config_dir:
-            config_dir = Path.cwd() / ".claude"
+            # Use the working directory determined during initialization
+            config_dir = self.working_directory / ".claude"
         
         results = {
             "config_dir": str(config_dir),
@@ -1059,12 +1119,13 @@ temperature: {temperature}"""
         agents = []
         
         if not self.templates_dir.exists():
-            self.logger.warning(f"Templates directory not found: {self.templates_dir}")
+            self.logger.warning(f"Agents directory not found: {self.templates_dir}")
             return agents
         
         template_files = sorted(self.templates_dir.glob("*.json"))
         # Filter out non-agent files - exclude system files and uppercase special files
-        excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README"}
+        # CRITICAL: PM (Project Manager) must NEVER be deployed as it's the main Claude instance
+        excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README", "pm", "PM", "project_manager"}
         template_files = [
             f for f in template_files 
             if f.stem not in excluded_names 
@@ -1253,7 +1314,8 @@ temperature: {temperature}"""
             Cleanup results
         """
         if not config_dir:
-            config_dir = Path.cwd() / ".claude"
+            # Use the working directory determined during initialization
+            config_dir = self.working_directory / ".claude"
         
         results = {
             "removed": [],
@@ -1904,4 +1966,128 @@ metadata:
         except Exception as e:
             self.logger.warning(f"Error extracting YAML field '{field_name}': {e}")
         
-        return None
+        return None
+    
+    def _validate_and_repair_existing_agents(self, agents_dir: Path) -> Dict[str, Any]:
+        """
+        Validate and repair broken frontmatter in existing agent files.
+        
+        This method scans existing .claude/agents/*.md files and validates their
+        frontmatter. If the frontmatter is broken or missing, it attempts to repair
+        it or marks the agent for replacement during deployment.
+        
+        WHY: Ensures all existing agents have valid YAML frontmatter before deployment,
+        preventing runtime errors in Claude Code when loading agents.
+        
+        Args:
+            agents_dir: Directory containing agent .md files
+            
+        Returns:
+            Dictionary with validation results:
+            - repaired: List of agent names that were repaired
+            - replaced: List of agent names marked for replacement
+            - errors: List of validation errors
+        """
+        results = {
+            "repaired": [],
+            "replaced": [],
+            "errors": []
+        }
+        
+        try:
+            # Import frontmatter validator
+            from claude_mpm.agents.frontmatter_validator import FrontmatterValidator
+            validator = FrontmatterValidator()
+            
+            # Find existing agent files
+            agent_files = list(agents_dir.glob("*.md"))
+            
+            if not agent_files:
+                self.logger.debug("No existing agent files to validate")
+                return results
+            
+            self.logger.debug(f"Validating frontmatter in {len(agent_files)} existing agents")
+            
+            for agent_file in agent_files:
+                try:
+                    agent_name = agent_file.stem
+                    
+                    # Read agent file content
+                    content = agent_file.read_text()
+                    
+                    # Check if this is a system agent (authored by claude-mpm)
+                    # Only repair system agents, leave user agents alone
+                    if "author: claude-mpm" not in content and "author: 'claude-mpm'" not in content:
+                        self.logger.debug(f"Skipping validation for user agent: {agent_name}")
+                        continue
+                    
+                    # Extract and validate frontmatter
+                    if not content.startswith("---"):
+                        # No frontmatter at all - mark for replacement
+                        self.logger.warning(f"Agent {agent_name} has no frontmatter, marking for replacement")
+                        results["replaced"].append(agent_name)
+                        # Delete the file so it will be recreated
+                        agent_file.unlink()
+                        continue
+                    
+                    # Try to extract frontmatter
+                    try:
+                        end_marker = content.find("\n---\n", 4)
+                        if end_marker == -1:
+                            end_marker = content.find("\n---\r\n", 4)
+                        
+                        if end_marker == -1:
+                            # Broken frontmatter - mark for replacement
+                            self.logger.warning(f"Agent {agent_name} has broken frontmatter, marking for replacement")
+                            results["replaced"].append(agent_name)
+                            # Delete the file so it will be recreated
+                            agent_file.unlink()
+                            continue
+                        
+                        # Validate frontmatter with the validator
+                        validation_result = validator.validate_file(agent_file)
+                        
+                        if not validation_result.is_valid:
+                            # Check if it can be corrected
+                            if validation_result.corrected_frontmatter:
+                                # Apply corrections
+                                correction_result = validator.correct_file(agent_file, dry_run=False)
+                                if correction_result.corrections:
+                                    results["repaired"].append(agent_name)
+                                    self.logger.info(f"Repaired frontmatter for agent {agent_name}")
+                                    for correction in correction_result.corrections:
+                                        self.logger.debug(f"  - {correction}")
+                            else:
+                                # Cannot be corrected - mark for replacement
+                                self.logger.warning(f"Agent {agent_name} has invalid frontmatter that cannot be repaired, marking for replacement")
+                                results["replaced"].append(agent_name)
+                                # Delete the file so it will be recreated
+                                agent_file.unlink()
+                        elif validation_result.warnings:
+                            # Has warnings but is valid
+                            for warning in validation_result.warnings:
+                                self.logger.debug(f"Agent {agent_name} warning: {warning}")
+                        
+                    except Exception as e:
+                        # Any error in parsing - mark for replacement
+                        self.logger.warning(f"Failed to parse frontmatter for {agent_name}: {e}, marking for replacement")
+                        results["replaced"].append(agent_name)
+                        # Delete the file so it will be recreated
+                        try:
+                            agent_file.unlink()
+                        except Exception:
+                            pass
+                    
+                except Exception as e:
+                    error_msg = f"Failed to validate agent {agent_file.name}: {e}"
+                    self.logger.error(error_msg)
+                    results["errors"].append(error_msg)
+            
+        except ImportError:
+            self.logger.warning("FrontmatterValidator not available, skipping validation")
+        except Exception as e:
+            error_msg = f"Agent validation failed: {e}"
+            self.logger.error(error_msg)
+            results["errors"].append(error_msg)
+        
+        return results

claude_mpm/services/agents/management/agent_management_service.py

@@ -57,7 +57,8 @@ class AgentManager:
             
         if project_dir is None:
             project_root = PathResolver.get_project_root()
-            self.project_dir = project_root / ConfigPaths.CONFIG_DIR / "agents" / "project-specific"
+            # Use direct agents directory without subdirectory to match deployment expectations
+            self.project_dir = project_root / ConfigPaths.CONFIG_DIR / "agents"
         else:
             self.project_dir = project_dir
         self.version_manager = AgentVersionManager()

claude_mpm/services/agents/registry/agent_registry.py

@@ -31,6 +31,7 @@ from enum import Enum
 
 from claude_mpm.core.config_paths import ConfigPaths
 from claude_mpm.services.memory.cache.simple_cache import SimpleCacheService
+from claude_mpm.agents.frontmatter_validator import FrontmatterValidator, ValidationResult
 
 logger = logging.getLogger(__name__)
 
@@ -130,6 +131,9 @@ class AgentRegistry:
         
         self.model_selector = model_selector
         
+        # Initialize frontmatter validator
+        self.frontmatter_validator = FrontmatterValidator()
+        
         # Registry storage
         self.registry: Dict[str, AgentMetadata] = {}
         self.discovery_paths: List[Path] = []
@@ -337,10 +341,27 @@ class AgentRegistry:
                             if len(parts) >= 3:
                                 frontmatter_text = parts[1].strip()
                                 data = yaml.safe_load(frontmatter_text)
+                                
+                                # Validate and correct frontmatter
+                                validation_result = self.frontmatter_validator.validate_and_correct(data)
+                                if validation_result.corrections:
+                                    logger.info(f"Applied corrections to {file_path.name}:")
+                                    for correction in validation_result.corrections:
+                                        logger.info(f"  - {correction}")
+                                    
+                                    # Use corrected frontmatter if available
+                                    if validation_result.corrected_frontmatter:
+                                        data = validation_result.corrected_frontmatter
+                                
+                                if validation_result.errors:
+                                    logger.warning(f"Validation errors in {file_path.name}:")
+                                    for error in validation_result.errors:
+                                        logger.warning(f"  - {error}")
+                                
                                 description = data.get('description', '')
                                 version = data.get('version', '0.0.0')
                                 capabilities = data.get('tools', [])  # Tools in .md format
-                                metadata = data.get('metadata', {})
+                                metadata = data
                             else:
                                 # No frontmatter, use defaults
                                 description = f"{file_path.stem} agent"

claude_mpm/services/framework_claude_md_generator/README.md

@@ -0,0 +1,92 @@
+# Framework CLAUDE.md Generator
+
+This directory contains the refactored framework CLAUDE.md generator service, originally a single 1,267-line file.
+
+## Structure
+
+### Core Modules
+
+- **`__init__.py`** (~250 lines) - Main facade class that coordinates all functionality
+- **`version_manager.py`** (~100 lines) - Handles version parsing, incrementing, and comparison
+- **`content_assembler.py`** (~120 lines) - Assembles sections and applies template variables
+- **`content_validator.py`** (~80 lines) - Validates generated content structure and completeness
+- **`deployment_manager.py`** (~80 lines) - Handles deployment to parent directories
+- **`section_manager.py`** (~60 lines) - Manages section registration, ordering, and updates
+
+### Section Generators
+
+The `section_generators/` subdirectory contains individual generators for each section:
+
+- **`__init__.py`** - Base classes and registry
+- **`header.py`** - Header with version metadata
+- **`role_designation.py`** - AI Assistant role designation
+- **`agents.py`** (~570 lines) - Comprehensive agents documentation (largest section)
+- **`todo_task_tools.py`** - Todo and Task Tools integration
+- **`claude_pm_init.py`** - Claude-PM initialization procedures
+- **`orchestration_principles.py`** - Core orchestration principles
+- **`subprocess_validation.py`** - Subprocess validation protocol
+- **`delegation_constraints.py`** - Critical delegation constraints
+- **`environment_config.py`** - Environment configuration
+- **`troubleshooting.py`** - Troubleshooting guide
+- **`core_responsibilities.py`** - Core responsibilities list
+- **`footer.py`** - Footer with metadata
+
+## Usage
+
+The API remains unchanged from the original implementation:
+
+```python
+from claude_pm.services.framework_claude_md_generator import FrameworkClaudeMdGenerator
+
+# Create generator instance
+generator = FrameworkClaudeMdGenerator()
+
+# Generate content
+content = generator.generate(
+    current_content=existing_content,  # Optional: for version auto-increment
+    template_variables={'PLATFORM': 'darwin', 'PYTHON_CMD': 'python3'}
+)
+
+# Deploy to parent directory
+success, message = generator.deploy_to_parent(Path('/parent/dir'))
+
+# Update a section
+generator.update_section('agents', 'Custom agents content')
+
+# Add custom section
+generator.add_custom_section('custom', 'Custom content', after='agents')
+```
+
+## Design Benefits
+
+1. **Modularity**: Each concern is separated into its own module
+2. **Maintainability**: Smaller, focused modules are easier to understand and modify
+3. **Testability**: Individual components can be tested in isolation
+4. **Extensibility**: New section generators can be added easily
+5. **Performance**: Section generators are loaded on demand
+6. **Backward Compatibility**: Original API preserved through facade pattern
+
+## Section Generator Pattern
+
+To add a new section generator:
+
+1. Create a new file in `section_generators/`
+2. Inherit from `BaseSectionGenerator`
+3. Implement the `generate()` method
+4. Register in `section_generators/__init__.py`
+
+Example:
+```python
+from . import BaseSectionGenerator
+
+class CustomSectionGenerator(BaseSectionGenerator):
+    def generate(self, data: Dict[str, Any]) -> str:
+        return "## Custom Section\n\nContent here..."
+```
+
+## Refactoring Summary
+
+- **Original**: 1,267 lines in a single file
+- **Refactored**: ~250 lines in main module + well-organized submodules
+- **Total line reduction**: Main module reduced by 80%
+- **Improved organization**: 13 focused modules instead of 1 large file

claude_mpm/services/framework_claude_md_generator/section_generators/agents.py

@@ -75,8 +75,8 @@ class AgentsGenerator(BaseSectionGenerator):
 **ALL AGENT OPERATIONS FOLLOW HIERARCHICAL PRECEDENCE**
 
 #### Agent Hierarchy (Highest to Lowest Priority)
-1. **Project Agents**: `$PROJECT/.claude-mpm/agents/project-specific/`
-   - Project-specific implementations and overrides
+1. **Project Agents**: `$PROJECT/.claude-mpm/agents/`
+   - Project implementations and overrides
    - Highest precedence for project context
    - Custom agents tailored to project requirements
 
@@ -376,7 +376,7 @@ for agent_id, metadata in agents.items():
 #### Directory Precedence Rules and Agent Discovery
 
 **Enhanced Agent Discovery Pattern (Highest to Lowest Priority):**
-1. **Project Agents**: `$PROJECT/.claude-mpm/agents/project-specific/`
+1. **Project Agents**: `$PROJECT/.claude-mpm/agents/`
 2. **Current Directory User Agents**: `$PWD/.claude-mpm/agents/user-agents/`
 3. **Parent Directory User Agents**: Walk up tree checking `../user-agents/`, `../../user-agents/`, etc.
 4. **User Home Agents**: `~/.claude-mpm/agents/user-defined/`

claude_mpm/services/framework_claude_md_generator/section_generators/claude_pm_init.py

@@ -79,9 +79,9 @@ claude-pm init --verify
    - Working directory context
 
 3. **Project Directory** (`$PROJECT_ROOT/.claude-mpm/`)
-   - Project-specific agents in `agents/project-specific/`
+   - Project agents in `agents/`
    - User agents in `agents/user-agents/` with directory precedence
-   - Project-specific configuration
+   - Project configuration
 
 ### Health Validation and Deployment Procedures
 

claude_mpm/services/version_control/VERSION

@@ -0,0 +1 @@
+0.9.0

claude_mpm/validation/agent_validator.py

@@ -53,6 +53,23 @@ class AgentValidator:
     - Privilege escalation (via tool combinations)
     """
     
+    # Model name mappings for normalization to tier names
+    MODEL_MAPPINGS = {
+        # Sonnet variations
+        "claude-3-5-sonnet-20241022": "sonnet",
+        "claude-3-5-sonnet-20240620": "sonnet",
+        "claude-sonnet-4-20250514": "sonnet",
+        "claude-4-sonnet-20250514": "sonnet",
+        "claude-3-sonnet-20240229": "sonnet",
+        # Opus variations
+        "claude-3-opus-20240229": "opus",
+        "claude-opus-4-20250514": "opus",
+        "claude-4-opus-20250514": "opus",
+        # Haiku variations
+        "claude-3-haiku-20240307": "haiku",
+        "claude-3-5-haiku-20241022": "haiku",
+    }
+    
     def __init__(self, schema_path: Optional[Path] = None):
         """Initialize the validator with the agent schema."""
         if schema_path is None:
@@ -83,6 +100,33 @@ class AgentValidator:
             logger.error(f"Failed to load schema from {self.schema_path}: {e}")
             raise
     
+    def _normalize_model(self, model: str) -> str:
+        """Normalize model name to standard tier (opus, sonnet, haiku).
+        
+        Args:
+            model: Original model name
+            
+        Returns:
+            Normalized model tier name
+        """
+        # Direct mapping check
+        if model in self.MODEL_MAPPINGS:
+            return self.MODEL_MAPPINGS[model]
+        
+        # Already normalized
+        if model in {"opus", "sonnet", "haiku"}:
+            return model
+        
+        # Check if model contains tier name
+        model_lower = model.lower()
+        for tier in {"opus", "sonnet", "haiku"}:
+            if tier in model_lower:
+                return tier
+        
+        # Default to sonnet if unrecognized
+        logger.warning(f"Unrecognized model '{model}', defaulting to 'sonnet'")
+        return "sonnet"
+    
     def validate_agent(self, agent_data: Dict[str, Any]) -> ValidationResult:
         """
         Validate a single agent configuration against the schema.
@@ -101,6 +145,14 @@ class AgentValidator:
         """
         result = ValidationResult(is_valid=True)
         
+        # Normalize model name before validation
+        if "capabilities" in agent_data and "model" in agent_data["capabilities"]:
+            original_model = agent_data["capabilities"]["model"]
+            normalized_model = self._normalize_model(original_model)
+            if original_model != normalized_model:
+                agent_data["capabilities"]["model"] = normalized_model
+                result.warnings.append(f"Normalized model from '{original_model}' to '{normalized_model}'")
+        
         # Perform JSON schema validation
         try:
             validate(instance=agent_data, schema=self.schema)
@@ -242,8 +294,11 @@ class AgentValidator:
         model = agent_data.get("capabilities", {}).get("model", "")
         tools = agent_data.get("capabilities", {}).get("tools", [])
         
+        # Normalize model name for comparison
+        normalized_model = self._normalize_model(model)
+        
         # Haiku models shouldn't use resource-intensive tools
-        if "haiku" in model.lower():
+        if normalized_model == "haiku":
             intensive_tools = {"docker", "kubectl", "terraform", "aws", "gcloud", "azure"}
             used_intensive = set(tools) & intensive_tools
             if used_intensive: