claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/core/agent_registry.py

@@ -1,24 +1,36 @@
 """
 Consolidated Agent Registry for Claude MPM.
 
-This module combines functionality from:
-- agent_registry.py (current working implementation)
-- agent_registry_original.py (legacy convenience functions)
+This module provides the primary interface for agent discovery and management.
+All functionality has been consolidated into the unified agent registry system.
 
-Provides:
+This module provides:
 - Agent discovery from the framework
 - Agent listing and selection
 - Compatibility with both sync and async interfaces
 - Legacy function names for backwards compatibility
 """
 
-import os
-import sys
-from pathlib import Path
-from typing import Optional, Dict, Any, List, Set
-import importlib.util
-from datetime import datetime
+import contextlib
+import warnings
 from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+# Import from the unified agent registry system
+from .unified_agent_registry import (
+    AgentMetadata as UnifiedAgentMetadata,
+    AgentTier,
+    AgentType,
+    discover_agents as unified_discover_agents,
+    get_agent as unified_get_agent,
+    get_agent_registry,
+    get_core_agents as unified_get_core_agents,
+    get_registry_stats as unified_get_registry_stats,
+    get_specialized_agents as unified_get_specialized_agents,
+    list_agents as unified_list_agents,
+)
 
 try:
     from ..core.logger import get_logger
@@ -26,9 +38,19 @@ except ImportError:
     from core.logger import get_logger
 
 
+# ============================================================================
+# Compatibility Classes - Delegate to Unified Agent Registry
+# ============================================================================
+
+
 @dataclass
 class AgentMetadata:
-    """Metadata for an agent."""
+    """
+    COMPATIBILITY WRAPPER for agent metadata.
+
+    This class now delegates to the UnifiedAgentRegistry system.
+    """
+
     name: str
     type: str
     path: str
@@ -36,421 +58,329 @@ class AgentMetadata:
     last_modified: float = 0.0
     specializations: List[str] = None
     description: str = ""
-    
+
     def __post_init__(self):
         if self.specializations is None:
             self.specializations = []
 
+    @classmethod
+    def from_unified(cls, unified_metadata: UnifiedAgentMetadata) -> "AgentMetadata":
+        """Create compatibility metadata from unified metadata."""
+        return cls(
+            name=unified_metadata.name,
+            type=unified_metadata.agent_type.value,
+            path=unified_metadata.path,
+            tier=unified_metadata.tier.value,
+            last_modified=unified_metadata.last_modified,
+            specializations=unified_metadata.specializations,
+            description=unified_metadata.description,
+        )
+
 
 class SimpleAgentRegistry:
-    """Simple agent registry implementation."""
-    
-    def __init__(self, framework_path: Path):
+    """
+    COMPATIBILITY WRAPPER for simple agent registry.
+
+    This class now delegates to the UnifiedAgentRegistry system.
+    """
+
+    def __init__(self, framework_path: Optional[Path] = None):
+        """Initialize with optional framework path (ignored in new implementation)."""
         self.framework_path = framework_path
+        self._unified_registry = get_agent_registry()
         self.agents = {}
         self._discover_agents()
-    
+
     def _discover_agents(self):
-        """Discover agents from the framework."""
-        # Check multiple possible locations
-        agent_locations = [
-            self.framework_path / "src" / "claude_mpm" / "agents" / "templates",
-            self.framework_path / "src" / "claude_mpm" / "agents",
-            self.framework_path / "agents",
-        ]
-        
-        for agents_dir in agent_locations:
-            if agents_dir.exists():
-                # Look for both .md and .json files
-                for pattern in ["*.md", "*.json"]:
-                    for agent_file in agents_dir.glob(pattern):
-                        agent_id = agent_file.stem
-                        self.agents[agent_id] = {
-                            'name': agent_id,
-                            'type': agent_id,
-                            'path': str(agent_file),
-                            'last_modified': agent_file.stat().st_mtime,
-                            'tier': self._determine_tier(agent_file),
-                            'specializations': self._extract_specializations(agent_id),
-                            'description': self._extract_description(agent_id)
-                        }
-    
+        """Discover agents using the unified registry."""
+        unified_agents = self._unified_registry.discover_agents()
+
+        # Convert to old format for compatibility
+        self.agents = {}
+        for name, unified_metadata in unified_agents.items():
+            self.agents[name] = {
+                "name": unified_metadata.name,
+                "type": unified_metadata.agent_type.value,
+                "path": unified_metadata.path,
+                "last_modified": unified_metadata.last_modified,
+                "tier": unified_metadata.tier.value,
+                "specializations": unified_metadata.specializations,
+                "description": unified_metadata.description,
+            }
+
     def _determine_tier(self, agent_path: Path) -> str:
-        """Determine agent tier based on path."""
-        path_str = str(agent_path)
-        if 'project' in path_str or '.claude-mpm' in path_str:
-            return 'project'
-        elif 'user' in path_str or str(Path.home()) in path_str:
-            return 'user'
-        else:
-            return 'system'
-    
+        """Determine agent tier based on path (compatibility method)."""
+        # Delegate to unified registry logic
+        if (
+            "project" in str(agent_path)
+            or ".claude-mpm" in str(agent_path)
+            or ".claude/agents" in str(agent_path)
+        ):
+            return "project"
+        if "user" in str(agent_path) or str(Path.home()) in str(agent_path):
+            return "user"
+        return "system"
+
     def _extract_specializations(self, agent_id: str) -> List[str]:
-        """Extract specializations based on agent type."""
+        """Extract specializations based on agent type (compatibility method)."""
         specialization_map = {
-            'engineer': ['coding', 'architecture', 'implementation'],
-            'documentation': ['docs', 'api', 'guides'],
-            'qa': ['testing', 'quality', 'validation'],
-            'research': ['analysis', 'investigation', 'exploration'],
-            'ops': ['deployment', 'monitoring', 'infrastructure'],
-            'security': ['security', 'audit', 'compliance'],
-            'version_control': ['git', 'versioning', 'releases'],
-            'data_engineer': ['data', 'etl', 'analytics']
+            "engineer": ["coding", "architecture", "implementation"],
+            "documentation": ["docs", "api", "guides"],
+            "qa": ["testing", "quality", "validation"],
+            "research": ["analysis", "investigation", "exploration"],
+            "ops": ["deployment", "monitoring", "infrastructure"],
+            "security": ["security", "audit", "compliance"],
+            "version_control": ["git", "versioning", "releases"],
+            "data_engineer": ["data", "etl", "analytics"],
         }
         return specialization_map.get(agent_id, [])
-    
+
     def _extract_description(self, agent_id: str) -> str:
-        """Extract description for agent."""
+        """Extract description for agent (compatibility method)."""
         descriptions = {
-            'engineer': 'Software engineering and implementation',
-            'documentation': 'Documentation creation and maintenance',
-            'qa': 'Quality assurance and testing',
-            'research': 'Research and investigation',
-            'ops': 'Operations and deployment',
-            'security': 'Security analysis and compliance',
-            'version_control': 'Version control and release management',
-            'data_engineer': 'Data engineering and analytics'
+            "engineer": "Software engineering and implementation",
+            "documentation": "Documentation creation and maintenance",
+            "qa": "Quality assurance and testing",
+            "research": "Research and investigation",
+            "ops": "Operations and deployment",
+            "security": "Security analysis and compliance",
+            "version_control": "Version control and release management",
+            "data_engineer": "Data engineering and analytics",
         }
-        return descriptions.get(agent_id, f'{agent_id.title()} agent')
-    
-    def listAgents(self, **kwargs) -> Dict[str, Any]:
-        """List all agents (camelCase for compatibility)."""
+        return descriptions.get(agent_id, f"{agent_id.title()} agent")
+
+    def list_agents(self, **kwargs) -> Dict[str, Any]:
+        """List all agents (compatibility method)."""
         return self.agents
-    
-    def list_agents(self, agent_type: Optional[str] = None, tier: Optional[str] = None) -> List[AgentMetadata]:
-        """List agents with optional filtering."""
-        results = []
-        for agent_id, metadata in self.agents.items():
-            if agent_type and metadata.get('type') != agent_type:
-                continue
-            if tier and metadata.get('tier') != tier:
-                continue
-            
-            results.append(AgentMetadata(
-                name=metadata['name'],
-                type=metadata['type'],
-                path=metadata['path'],
-                tier=metadata.get('tier', 'system'),
-                last_modified=metadata.get('last_modified', 0),
-                specializations=metadata.get('specializations', []),
-                description=metadata.get('description', '')
-            ))
-        return results
-    
+
+    def listAgents(self, **kwargs) -> Dict[str, Any]:
+        """DEPRECATED: Use list_agents() instead. Kept for backward compatibility."""
+        warnings.warn(
+            "listAgents() is deprecated, use list_agents() instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.list_agents(**kwargs)
+
+    def list_agents_filtered(
+        self, agent_type: Optional[str] = None, tier: Optional[str] = None
+    ) -> List[AgentMetadata]:
+        """List agents with optional filtering (compatibility method)."""
+        # Use unified registry for filtering
+        unified_tier = None
+        unified_agent_type = None
+
+        if tier:
+            unified_tier = AgentTier(tier)
+        if agent_type:
+            try:
+                unified_agent_type = AgentType(agent_type)
+            except ValueError:
+                # Handle legacy agent types
+                unified_agent_type = None
+
+        unified_agents = self._unified_registry.list_agents(
+            tier=unified_tier, agent_type=unified_agent_type
+        )
+
+        return [AgentMetadata.from_unified(agent) for agent in unified_agents]
+
     def get_agent(self, agent_name: str) -> Optional[AgentMetadata]:
-        """Get a specific agent."""
-        metadata = self.agents.get(agent_name)
-        if metadata:
-            return AgentMetadata(
-                name=metadata['name'],
-                type=metadata['type'],
-                path=metadata['path'],
-                tier=metadata.get('tier', 'system'),
-                last_modified=metadata.get('last_modified', 0),
-                specializations=metadata.get('specializations', []),
-                description=metadata.get('description', '')
-            )
+        """Get a specific agent (compatibility method)."""
+        unified_agent = self._unified_registry.get_agent(agent_name)
+        if unified_agent:
+            return AgentMetadata.from_unified(unified_agent)
         return None
-    
+
     def discover_agents(self, force_refresh: bool = False) -> Dict[str, AgentMetadata]:
-        """Discover agents (optionally refresh)."""
-        if force_refresh:
-            self.agents.clear()
-            self._discover_agents()
-        
+        """Discover agents (compatibility method)."""
+        unified_agents = self._unified_registry.discover_agents(
+            force_refresh=force_refresh
+        )
+
+        # Update internal agents dict for compatibility
+        self.agents = {}
+        for name, unified_metadata in unified_agents.items():
+            self.agents[name] = {
+                "name": unified_metadata.name,
+                "type": unified_metadata.agent_type.value,
+                "path": unified_metadata.path,
+                "last_modified": unified_metadata.last_modified,
+                "tier": unified_metadata.tier.value,
+                "specializations": unified_metadata.specializations,
+                "description": unified_metadata.description,
+            }
+
+        # Return compatibility format
         return {
-            agent_id: AgentMetadata(
-                name=metadata['name'],
-                type=metadata['type'],
-                path=metadata['path'],
-                tier=metadata.get('tier', 'system'),
-                last_modified=metadata.get('last_modified', 0),
-                specializations=metadata.get('specializations', []),
-                description=metadata.get('description', '')
-            )
-            for agent_id, metadata in self.agents.items()
+            name: AgentMetadata.from_unified(unified_metadata)
+            for name, unified_metadata in unified_agents.items()
         }
-    
+
     @property
     def core_agent_types(self) -> Set[str]:
-        """Get core agent types."""
+        """Get core agent types (compatibility property)."""
         return {
-            'documentation',
-            'engineer', 
-            'qa',
-            'research',
-            'ops',
-            'security',
-            'version_control',
-            'data_engineer'
+            "documentation",
+            "engineer",
+            "qa",
+            "research",
+            "ops",
+            "security",
+            "version_control",
+            "data_engineer",
         }
-    
+
     @property
     def specialized_agent_types(self) -> Set[str]:
-        """Get specialized agent types beyond core."""
-        all_types = set(metadata['type'] for metadata in self.agents.values())
+        """Get specialized agent types beyond core (compatibility property)."""
+        all_types = {metadata["type"] for metadata in self.agents.values()}
         return all_types - self.core_agent_types
 
 
 class AgentRegistryAdapter:
     """
-    Adapter to integrate agent registry functionality.
-    
-    This adapter:
-    1. Locates the claude-mpm installation
-    2. Provides a clean interface for agent operations
-    3. Maintains backwards compatibility
+    COMPATIBILITY WRAPPER for agent registry adapter.
+
+    This adapter now delegates to the UnifiedAgentRegistry system.
     """
-    
+
     def __init__(self, framework_path: Optional[Path] = None):
-        """
-        Initialize the agent registry adapter.
-        
-        Args:
-            framework_path: Path to claude-mpm (auto-detected if None)
-        """
+        """Initialize the agent registry adapter (framework_path ignored in new implementation)."""
         self.logger = get_logger("agent_registry")
-        self.framework_path = framework_path or self._find_framework()
-        self.registry = None
-        self._initialize_registry()
-    
+        self.framework_path = framework_path  # Kept for compatibility
+        self._unified_registry = get_agent_registry()
+        self.registry = SimpleAgentRegistry(framework_path)
+
     def _find_framework(self) -> Optional[Path]:
-        """Find claude-mpm installation.
-        
-        Search order:
-        1. CLAUDE_MPM_PATH environment variable
-        2. Current working directory (if it's claude-mpm)
-        3. Walk up from current file location
-        4. Common development locations
-        """
-        # Check environment variable first
-        env_path = os.environ.get("CLAUDE_MPM_PATH")
-        if env_path:
-            candidate = Path(env_path)
-            if self._is_valid_framework_path(candidate):
-                self.logger.info(f"Using claude-mpm from CLAUDE_MPM_PATH: {candidate}")
-                return candidate
-            else:
-                self.logger.warning(f"CLAUDE_MPM_PATH is set but invalid: {env_path}")
-        
-        # Check current working directory
-        cwd = Path.cwd()
-        if self._is_valid_framework_path(cwd):
-            return cwd
-            
-        # Check if we're running from within the installed package
-        current_file = Path(__file__).resolve()
-        for parent in current_file.parents:
-            if self._is_valid_framework_path(parent):
-                return parent
-            # Stop at site-packages or similar
-            if parent.name in ("site-packages", "dist-packages", "lib"):
-                break
-        
-        # Check common development locations
-        candidates = [
-            Path.home() / "Projects" / "claude-mpm",
-            Path.home() / "claude-mpm",
-        ]
-        
-        for candidate in candidates:
-            if self._is_valid_framework_path(candidate):
-                self.logger.info(f"Found claude-mpm at: {candidate}")
-                return candidate
-        
-        return None
-    
+        """Find claude-mpm installation (compatibility method)."""
+        # Delegate to unified path manager
+        from .unified_paths import get_path_manager
+
+        return get_path_manager().framework_root
+
     def _is_valid_framework_path(self, path: Path) -> bool:
-        """Check if a path is a valid claude-mpm installation."""
-        return (
-            path.exists() and 
-            (path / "src" / "claude_mpm").exists()
-        )
-    
+        """Check if a path is a valid claude-mpm installation (compatibility method)."""
+        return path.exists() and (path / "src" / "claude_mpm").exists()
+
     def _initialize_registry(self):
-        """Initialize the agent registry."""
-        if not self.framework_path:
-            self.logger.warning("No framework path, registry unavailable")
-            return
-        
-        try:
-            self.registry = SimpleAgentRegistry(self.framework_path)
-            self.logger.info("Agent registry initialized successfully")
-            
-        except Exception as e:
-            self.logger.error(f"Failed to initialize registry: {e}")
-    
+        """Initialize the agent registry (compatibility method)."""
+        # Registry is already initialized in __init__
+
     def list_agents(self, **kwargs) -> Dict[str, Any]:
-        """
-        List available agents.
-        
-        Args:
-            **kwargs: Arguments to pass to registry
-            
-        Returns:
-            Dictionary of agents with metadata
-        """
-        if not self.registry:
-            return {}
-        
+        """List available agents (compatibility method)."""
         try:
-            return self.registry.listAgents(**kwargs)
+            return self.registry.list_agents(**kwargs)
         except Exception as e:
             self.logger.error(f"Error listing agents: {e}")
             return {}
-    
+
     def get_agent_definition(self, agent_name: str) -> Optional[str]:
-        """
-        Get agent definition by name.
-        
-        Args:
-            agent_name: Name of the agent
-            
-        Returns:
-            Agent definition content or None
-        """
-        if not self.registry:
-            return None
-        
+        """Get agent definition by name (compatibility method)."""
         try:
-            # Try to load agent definition
-            agents = self.registry.listAgents()
-            for agent_id, metadata in agents.items():
-                if agent_name in agent_id or agent_name == metadata.get('type'):
-                    # Load the agent file
-                    agent_path = Path(metadata['path'])
-                    if agent_path.exists():
-                        return agent_path.read_text()
-            
+            unified_agent = self._unified_registry.get_agent(agent_name)
+            if unified_agent:
+                agent_path = Path(unified_agent.path)
+                if agent_path.exists():
+                    return agent_path.read_text()
             return None
-            
         except Exception as e:
             self.logger.error(f"Error getting agent definition: {e}")
             return None
-    
-    def select_agent_for_task(self, task_description: str, required_specializations: Optional[List[str]] = None) -> Optional[Dict[str, Any]]:
-        """
-        Select optimal agent for a task.
-        
-        Args:
-            task_description: Description of the task
-            required_specializations: Required agent specializations
-            
-        Returns:
-            Agent metadata or None
-        """
-        if not self.registry:
-            return None
-        
+
+    def select_agent_for_task(
+        self,
+        task_description: str,
+        required_specializations: Optional[List[str]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Select optimal agent for a task (compatibility method)."""
         try:
-            # Get agents with required specializations
-            agents = self.registry.listAgents()
-            
+            # Get all agents from unified registry
+            unified_agents = self._unified_registry.list_agents()
+
             if required_specializations:
                 # Filter by specializations
-                filtered = {}
-                for agent_id, metadata in agents.items():
-                    agent_specs = set(metadata.get('specializations', []))
+                filtered = []
+                for agent in unified_agents:
+                    agent_specs = set(agent.specializations)
                     if any(spec in agent_specs for spec in required_specializations):
-                        filtered[agent_id] = metadata
-                agents = filtered
-            
-            if not agents:
+                        filtered.append(agent)
+                unified_agents = filtered
+
+            if not unified_agents:
                 return None
-            
-            # For now, return the first matching agent
-            # In future, could implement more sophisticated selection
-            agent_id = next(iter(agents))
+
+            # Return the first matching agent in compatibility format
+            agent = unified_agents[0]
             return {
-                'id': agent_id,
-                'metadata': agents[agent_id]
+                "id": agent.name,
+                "metadata": {
+                    "name": agent.name,
+                    "type": agent.agent_type.value,
+                    "path": agent.path,
+                    "tier": agent.tier.value,
+                    "specializations": agent.specializations,
+                    "description": agent.description,
+                },
             }
-            
+
         except Exception as e:
             self.logger.error(f"Error selecting agent: {e}")
             return None
-    
+
     def get_agent_hierarchy(self) -> Dict[str, List[str]]:
-        """
-        Get agent hierarchy (project → user → system).
-        
-        Returns:
-            Dictionary with hierarchy levels and agent names
-        """
-        if not self.registry:
-            return {
-                'project': [],
-                'user': [],
-                'system': []
-            }
-        
+        """Get agent hierarchy (compatibility method)."""
         try:
-            # Get all agents
-            all_agents = self.registry.listAgents()
-            
-            hierarchy = {
-                'project': [],
-                'user': [],
-                'system': []
-            }
-            
-            # Categorize by tier
-            for agent_id, metadata in all_agents.items():
-                tier = metadata.get('tier', 'system')
-                hierarchy[tier].append(agent_id)
-            
+            hierarchy = {"project": [], "user": [], "system": []}
+
+            # Get agents by tier from unified registry
+            for tier in [AgentTier.PROJECT, AgentTier.USER, AgentTier.SYSTEM]:
+                agents = self._unified_registry.list_agents(tier=tier)
+                hierarchy[tier.value] = [agent.name for agent in agents]
+
             return hierarchy
-            
+
         except Exception as e:
             self.logger.error(f"Error getting hierarchy: {e}")
-            return {'project': [], 'user': [], 'system': []}
-    
+            return {"project": [], "user": [], "system": []}
+
     def get_core_agents(self) -> List[str]:
-        """
-        Get list of core system agents.
-        
-        Returns:
-            List of core agent names
-        """
-        return [
-            'documentation',
-            'engineer', 
-            'qa',
-            'research',
-            'ops',
-            'security',
-            'version_control',
-            'data_engineer'
-        ]
-    
-    def format_agent_for_task_tool(self, agent_name: str, task: str, context: str = "") -> str:
-        """
-        Format agent delegation for Task Tool.
-        
-        Args:
-            agent_name: Name of the agent
-            task: Task description
-            context: Additional context
-            
-        Returns:
-            Formatted Task Tool prompt
-        """
+        """Get list of core system agents (compatibility method)."""
+        try:
+            core_agents = self._unified_registry.get_core_agents()
+            return [agent.name for agent in core_agents]
+        except Exception as e:
+            self.logger.error(f"Error getting core agents: {e}")
+            return [
+                "documentation",
+                "engineer",
+                "qa",
+                "research",
+                "ops",
+                "security",
+                "version_control",
+                "data_engineer",
+            ]
+
+    def format_agent_for_task_tool(
+        self, agent_name: str, task: str, context: str = ""
+    ) -> str:
+        """Format agent delegation for Task Tool (compatibility method)."""
         # Map agent names to nicknames
         nicknames = {
-            'documentation': 'Documenter',
-            'engineer': 'Engineer',
-            'qa': 'QA',
-            'research': 'Researcher',
-            'ops': 'Ops',
-            'security': 'Security',
-            'version_control': 'Versioner',
-            'data_engineer': 'Data Engineer'
+            "documentation": "Documenter",
+            "engineer": "Engineer",
+            "qa": "QA",
+            "research": "Researcher",
+            "ops": "Ops",
+            "security": "Security",
+            "version_control": "Versioner",
+            "data_engineer": "Data Engineer",
         }
-        
+
         nickname = nicknames.get(agent_name, agent_name.title())
-        
-        today = datetime.now().strftime("%Y-%m-%d")
-        
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
         return f"""**{nickname}**: {task}
 
 TEMPORAL CONTEXT: Today is {today}. Apply date awareness to task execution.
@@ -463,165 +393,128 @@ TEMPORAL CONTEXT: Today is {today}. Apply date awareness to task execution.
 **Expected Results**: Completed task with operational insights"""
 
 
+# ============================================================================
+# Compatibility Functions - Delegate to Unified Agent Registry
+# ============================================================================
+
 # Export main class as AgentRegistry for compatibility
 AgentRegistry = SimpleAgentRegistry
 
-# Convenience functions for backwards compatibility
-def create_agent_registry(cache_service: Any = None, framework_path: Optional[Path] = None) -> AgentRegistry:
-    """
-    Create a new AgentRegistry instance
-    
-    Args:
-        cache_service: Ignored for compatibility
-        framework_path: Path to framework (auto-detected if None)
-        
-    Returns:
-        AgentRegistry instance
-    """
-    if not framework_path:
-        adapter = AgentRegistryAdapter()
-        framework_path = adapter.framework_path
-    
-    if framework_path:
-        return AgentRegistry(framework_path)
-    else:
-        raise ValueError("Could not find claude-mpm framework path")
+
+def create_agent_registry(
+    cache_service: Any = None, framework_path: Optional[Path] = None
+) -> AgentRegistry:
+    """Create a new AgentRegistry instance (compatibility function)."""
+    # Ignore parameters and use unified registry
+    return AgentRegistry(framework_path)
+
 
 def discover_agents(force_refresh: bool = False) -> Dict[str, AgentMetadata]:
-    """
-    Convenience function for synchronous agent discovery
-    
-    Args:
-        force_refresh: Force cache refresh
-        
-    Returns:
-        Dictionary of discovered agents
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        return adapter.registry.discover_agents(force_refresh=force_refresh)
-    return {}
+    """Convenience function for synchronous agent discovery (compatibility function)."""
+    return unified_discover_agents()
+
 
 def get_core_agent_types() -> Set[str]:
-    """
-    Get the set of core agent types
-    
-    Returns:
-        Set of core agent type names
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        return adapter.registry.core_agent_types
-    return set()
+    """Get the set of core agent types (compatibility function)."""
+    core_agents = unified_get_core_agents()
+    return {agent.name for agent in core_agents}
+
 
 def get_specialized_agent_types() -> Set[str]:
-    """
-    Get the set of specialized agent types beyond core 9
-    
-    Returns:
-        Set of specialized agent type names
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        return adapter.registry.specialized_agent_types
-    return set()
+    """Get the set of specialized agent types (compatibility function)."""
+    specialized_agents = unified_get_specialized_agents()
+    return {agent.name for agent in specialized_agents}
+
+
+def list_agents_all() -> Dict[str, Dict[str, Any]]:
+    """Synchronous function for listing all agents (compatibility function)."""
+    unified_agents = unified_discover_agents()
+    return {
+        name: {
+            "name": metadata.name,
+            "type": metadata.agent_type.value,
+            "path": metadata.path,
+            "tier": metadata.tier.value,
+            "last_modified": metadata.last_modified,
+            "specializations": metadata.specializations,
+            "description": metadata.description,
+        }
+        for name, metadata in unified_agents.items()
+    }
+
 
 def listAgents() -> Dict[str, Dict[str, Any]]:
-    """
-    Synchronous function for listing all agents (camelCase compatibility)
-    
-    Returns:
-        Dictionary of agent name -> agent metadata
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        return adapter.registry.listAgents()
-    return {}
+    """DEPRECATED: Use list_agents_all() instead (compatibility function)."""
+    warnings.warn(
+        "listAgents() is deprecated, use list_agents_all() instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return list_agents_all()
+
+
+def list_agents(
+    agent_type: Optional[str] = None, tier: Optional[str] = None
+) -> List[AgentMetadata]:
+    """Synchronous function to list agents with optional filtering (compatibility function)."""
+    # Convert parameters to unified types
+    unified_tier = None
+    unified_agent_type = None
+
+    if tier:
+        with contextlib.suppress(ValueError):
+            unified_tier = AgentTier(tier)
+
+    if agent_type:
+        with contextlib.suppress(ValueError):
+            unified_agent_type = AgentType(agent_type)
+
+    unified_agents = unified_list_agents(
+        tier=unified_tier, agent_type=unified_agent_type
+    )
+    return [AgentMetadata.from_unified(agent) for agent in unified_agents]
 
-def list_agents(agent_type: Optional[str] = None, tier: Optional[str] = None) -> List[AgentMetadata]:
-    """
-    Synchronous function to list agents with optional filtering
-    
-    Args:
-        agent_type: Filter by agent type
-        tier: Filter by hierarchy tier
-        
-    Returns:
-        List of agent metadata dictionaries
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        return adapter.registry.list_agents(agent_type=agent_type, tier=tier)
-    return []
 
 def discover_agents_sync(force_refresh: bool = False) -> Dict[str, AgentMetadata]:
-    """
-    Synchronous function for agent discovery
-    
-    Args:
-        force_refresh: Force cache refresh
-        
-    Returns:
-        Dictionary of discovered agents
-    """
+    """Synchronous function for agent discovery (compatibility function)."""
     return discover_agents(force_refresh)
 
+
 def get_agent(agent_name: str) -> Optional[Dict[str, Any]]:
-    """
-    Synchronous function to get a specific agent
-    
-    Args:
-        agent_name: Name of agent to retrieve
-        
-    Returns:
-        Agent metadata or None
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        agent = adapter.registry.get_agent(agent_name)
-        if agent:
-            return {
-                'name': agent.name,
-                'type': agent.type,
-                'path': agent.path,
-                'tier': agent.tier,
-                'last_modified': agent.last_modified,
-                'specializations': agent.specializations,
-                'description': agent.description
-            }
+    """Synchronous function to get a specific agent (compatibility function)."""
+    unified_agent = unified_get_agent(agent_name)
+    if unified_agent:
+        return {
+            "name": unified_agent.name,
+            "type": unified_agent.agent_type.value,
+            "path": unified_agent.path,
+            "tier": unified_agent.tier.value,
+            "last_modified": unified_agent.last_modified,
+            "specializations": unified_agent.specializations,
+            "description": unified_agent.description,
+        }
     return None
 
+
 def get_registry_stats() -> Dict[str, Any]:
-    """
-    Synchronous function to get registry statistics
-    
-    Returns:
-        Dictionary of registry statistics
-    """
-    adapter = AgentRegistryAdapter()
-    if adapter.registry:
-        agents = adapter.registry.list_agents()
-        return {
-            'total_agents': len(agents),
-            'agent_types': len(set(a.type for a in agents)),
-            'tiers': list(set(a.tier for a in agents))
-        }
-    return {'total_agents': 0, 'agent_types': 0, 'tiers': []}
+    """Synchronous function to get registry statistics (compatibility function)."""
+    return unified_get_registry_stats()
 
 
 # Export all public symbols
 __all__ = [
-    'AgentRegistry',
-    'AgentRegistryAdapter', 
-    'AgentMetadata',
-    'SimpleAgentRegistry',
-    'create_agent_registry',
-    'discover_agents',
-    'get_core_agent_types',
-    'get_specialized_agent_types',
-    'listAgents',
-    'list_agents',
-    'discover_agents_sync',
-    'get_agent',
-    'get_registry_stats'
-]
+    "AgentMetadata",
+    "AgentRegistry",
+    "AgentRegistryAdapter",
+    "SimpleAgentRegistry",
+    "create_agent_registry",
+    "discover_agents",
+    "discover_agents_sync",
+    "get_agent",
+    "get_core_agent_types",
+    "get_registry_stats",
+    "get_specialized_agent_types",
+    "listAgents",  # Deprecated
+    "list_agents",
+    "list_agents_all",
+]