claude-mpm 3.4.24__py3-none-any.whl → 3.4.27__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-3.4.18
+3.4.27

claude_mpm/cli/__init__.py

@@ -69,6 +69,9 @@ def main(argv: Optional[list] = None):
     # Ensure directories are initialized on first run
     ensure_directories()
     
+    # Initialize or update project registry
+    _initialize_project_registry()
+    
     # Create parser with version
     parser = create_parser(version=__version__)
     
@@ -110,6 +113,29 @@ def main(argv: Optional[list] = None):
         return 1
 
 
+def _initialize_project_registry():
+    """
+    Initialize or update the project registry for the current session.
+    
+    WHY: The project registry tracks all claude-mpm projects and their metadata
+    across sessions. This function ensures the current project is properly
+    registered and updates session information.
+    
+    DESIGN DECISION: Registry failures are logged but don't prevent startup
+    to ensure claude-mpm remains functional even if registry operations fail.
+    """
+    try:
+        from ..services.project_registry import ProjectRegistry
+        registry = ProjectRegistry()
+        registry.get_or_create_project_entry()
+    except Exception as e:
+        # Import logger here to avoid circular imports
+        from ..core.logger import get_logger
+        logger = get_logger("cli")
+        logger.debug(f"Failed to initialize project registry: {e}")
+        # Continue execution - registry failure shouldn't block startup
+
+
 def _ensure_run_attributes(args):
     """
     Ensure run command attributes exist when defaulting to run.

claude_mpm/init.py

@@ -30,6 +30,7 @@ class ProjectInitializer:
           - config/
           - logs/
           - templates/
+          - registry/
         """
         try:
             # Create main user directory
@@ -41,6 +42,7 @@ class ProjectInitializer:
                 self.user_dir / "config",
                 self.user_dir / "logs",
                 self.user_dir / "templates",
+                self.user_dir / "registry",
             ]
             
             for directory in directories:

claude_mpm/services/project_registry.py

@@ -0,0 +1,602 @@
+"""
+Project Registry Service.
+
+WHY: This service manages a persistent registry of claude-mpm projects to enable
+project identification, tracking, and metadata management. The registry stores
+comprehensive project information including git status, environment details,
+runtime information, and project characteristics.
+
+DESIGN DECISION: Uses YAML for human-readable registry files stored in the user's
+home directory (~/.claude-mpm/registry/). Each project gets a unique UUID-based
+registry file to avoid conflicts and enable easy project identification.
+
+The registry captures both static project information (paths, git info) and
+dynamic runtime information (startup times, process IDs, command line args)
+to provide complete project lifecycle tracking.
+"""
+
+import os
+import sys
+import uuid
+import subprocess
+import platform
+import shutil
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+import yaml
+
+from claude_mpm.core.logger import get_logger
+
+
+class ProjectRegistryError(Exception):
+    """Base exception for project registry operations."""
+    pass
+
+
+class ProjectRegistry:
+    """
+    Manages the project registry for claude-mpm installations.
+    
+    WHY: The project registry provides persistent project tracking across sessions,
+    enabling project identification, metadata collection, and usage analytics.
+    This is crucial for multi-project environments where users switch between
+    different codebases.
+    
+    DESIGN DECISION: Registry files are stored in ~/.claude-mpm/registry/ with
+    UUID-based filenames to ensure uniqueness and avoid conflicts. The registry
+    uses YAML for human readability and ease of manual inspection/editing.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the project registry.
+        
+        WHY: Sets up the registry directory and logger. The registry directory
+        is created in the user's home directory to persist across project
+        directories and system reboots.
+        """
+        self.logger = get_logger("project_registry")
+        self.registry_dir = Path.home() / ".claude-mpm" / "registry"
+        self.current_project_path = Path.cwd().resolve()
+        
+        # Ensure registry directory exists
+        try:
+            self.registry_dir.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            self.logger.error(f"Failed to create registry directory: {e}")
+            raise ProjectRegistryError(f"Cannot create registry directory: {e}")
+    
+    def get_or_create_project_entry(self) -> Dict[str, Any]:
+        """
+        Get existing project registry entry or create a new one.
+        
+        WHY: This is the main entry point for project registration. It handles
+        both new project registration and existing project updates, ensuring
+        that every claude-mpm session is properly tracked.
+        
+        DESIGN DECISION: Matching is done by normalized absolute path to handle
+        symbolic links and different path representations consistently.
+        
+        Returns:
+            Dictionary containing the project registry data
+            
+        Raises:
+            ProjectRegistryError: If registry operations fail
+        """
+        try:
+            # Look for existing registry entry
+            existing_entry = self._find_existing_entry()
+            
+            if existing_entry:
+                self.logger.debug(f"Found existing project entry: {existing_entry['project_id']}")
+                # Update existing entry with current session info
+                return self._update_existing_entry(existing_entry)
+            else:
+                self.logger.debug("Creating new project registry entry")
+                # Create new entry
+                return self._create_new_entry()
+                
+        except Exception as e:
+            self.logger.error(f"Failed to get or create project entry: {e}")
+            raise ProjectRegistryError(f"Registry operation failed: {e}")
+    
+    def _find_existing_entry(self) -> Optional[Dict[str, Any]]:
+        """
+        Search for existing registry entry matching current project path.
+        
+        WHY: We need to match projects by their absolute path to avoid creating
+        duplicate entries when the same project is accessed from different
+        working directories or via different path representations.
+        
+        Returns:
+            Existing registry data if found, None otherwise
+        """
+        try:
+            # Normalize current path for consistent matching
+            current_path_str = str(self.current_project_path)
+            
+            # Search all registry files
+            for registry_file in self.registry_dir.glob("*.yaml"):
+                try:
+                    with open(registry_file, 'r', encoding='utf-8') as f:
+                        data = yaml.safe_load(f) or {}
+                    
+                    # Check if project_path matches
+                    if data.get('project_path') == current_path_str:
+                        data['_registry_file'] = registry_file  # Add file reference
+                        return data
+                        
+                except Exception as e:
+                    self.logger.warning(f"Failed to read registry file {registry_file}: {e}")
+                    continue
+            
+            return None
+            
+        except Exception as e:
+            self.logger.error(f"Error searching for existing entry: {e}")
+            return None
+    
+    def _create_new_entry(self) -> Dict[str, Any]:
+        """
+        Create a new project registry entry.
+        
+        WHY: New projects need to be registered with comprehensive metadata
+        including project information, environment details, and initial runtime
+        data. This creates a complete snapshot of the project at first access.
+        
+        Returns:
+            Newly created registry data
+        """
+        project_id = str(uuid.uuid4())
+        registry_file = self.registry_dir / f"{project_id}.yaml"
+        
+        # Build comprehensive project data
+        project_data = {
+            'project_id': project_id,
+            'project_path': str(self.current_project_path),
+            'project_name': self.current_project_path.name,
+            'metadata': self._build_metadata(is_new=True),
+            'runtime': self._build_runtime_info(),
+            'environment': self._build_environment_info(),
+            'git': self._build_git_info(),
+            'session': self._build_session_info(),
+            'project_info': self._build_project_info()
+        }
+        
+        # Save to registry file
+        self._save_registry_data(registry_file, project_data)
+        project_data['_registry_file'] = registry_file
+        
+        self.logger.info(f"Created new project registry entry: {project_id}")
+        return project_data
+    
+    def _update_existing_entry(self, existing_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update existing project registry entry with current session information.
+        
+        WHY: Existing projects need their metadata updated to reflect current
+        access patterns, runtime information, and any changes in project state.
+        This maintains accurate usage tracking and project state history.
+        
+        Args:
+            existing_data: The existing registry data to update
+            
+        Returns:
+            Updated registry data
+        """
+        registry_file = existing_data.get('_registry_file')
+        if not registry_file:
+            raise ProjectRegistryError("Registry file reference missing from existing data")
+        
+        # Update timestamps and counters
+        metadata = existing_data.get('metadata', {})
+        access_count = metadata.get('access_count', 0) + 1
+        now = datetime.now(timezone.utc).isoformat()
+        
+        existing_data['metadata'].update({
+            'updated_at': now,
+            'last_accessed': now,
+            'access_count': access_count
+        })
+        
+        # Update runtime information
+        existing_data['runtime'] = self._build_runtime_info()
+        
+        # Update session information
+        existing_data['session'] = self._build_session_info()
+        
+        # Update git information (may have changed)
+        existing_data['git'] = self._build_git_info()
+        
+        # Update project info (may have changed)
+        existing_data['project_info'] = self._build_project_info()
+        
+        # Save updated data
+        self._save_registry_data(registry_file, existing_data)
+        
+        self.logger.debug(f"Updated project registry entry (access #{access_count})")
+        return existing_data
+    
+    def _build_metadata(self, is_new: bool = False) -> Dict[str, Any]:
+        """
+        Build metadata section for registry entry.
+        
+        WHY: Metadata tracks creation, modification, and access patterns for
+        analytics and project lifecycle management.
+        """
+        now = datetime.now(timezone.utc).isoformat()
+        
+        metadata = {
+            'updated_at': now,
+            'last_accessed': now,
+            'access_count': 1
+        }
+        
+        if is_new:
+            metadata['created_at'] = now
+        
+        return metadata
+    
+    def _build_runtime_info(self) -> Dict[str, Any]:
+        """
+        Build runtime information section.
+        
+        WHY: Runtime information helps track session lifecycle, process management,
+        and system state. This is valuable for debugging session issues and
+        understanding usage patterns.
+        """
+        # Get claude-mpm version
+        try:
+            from claude_mpm import __version__ as claude_mpm_version
+        except ImportError:
+            claude_mpm_version = "unknown"
+        
+        return {
+            'startup_time': datetime.now(timezone.utc).isoformat(),
+            'pid': os.getpid(),
+            'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            'claude_mpm_version': claude_mpm_version,
+            'command_line': ' '.join(sys.argv),
+            'launch_method': 'subprocess'  # Default, could be detected based on parent process
+        }
+    
+    def _build_environment_info(self) -> Dict[str, Any]:
+        """
+        Build environment information section.
+        
+        WHY: Environment information helps with debugging, platform-specific
+        behavior analysis, and provides context for project usage patterns
+        across different systems and user setups.
+        """
+        return {
+            'user': os.getenv('USER') or os.getenv('USERNAME', 'unknown'),
+            'hostname': platform.node(),
+            'os': platform.system(),
+            'os_version': platform.release(),
+            'shell': os.getenv('SHELL', 'unknown'),
+            'terminal': os.getenv('TERM', 'unknown'),
+            'cwd': str(Path.cwd())
+        }
+    
+    def _build_git_info(self) -> Dict[str, Any]:
+        """
+        Build git repository information.
+        
+        WHY: Git information is crucial for project identification and tracking
+        changes across different branches and commits. This helps understand
+        project state and enables better project management features.
+        """
+        git_info = {
+            'is_repo': False,
+            'branch': None,
+            'remote_url': None,
+            'last_commit': None,
+            'has_uncommitted': False
+        }
+        
+        try:
+            # Check if we're in a git repository
+            result = subprocess.run(
+                ['git', 'rev-parse', '--git-dir'],
+                cwd=self.current_project_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.returncode == 0:
+                git_info['is_repo'] = True
+                
+                # Get current branch
+                try:
+                    result = subprocess.run(
+                        ['git', 'branch', '--show-current'],
+                        cwd=self.current_project_path,
+                        capture_output=True,
+                        text=True,
+                        timeout=5
+                    )
+                    if result.returncode == 0:
+                        git_info['branch'] = result.stdout.strip()
+                except Exception:
+                    pass
+                
+                # Get remote URL
+                try:
+                    result = subprocess.run(
+                        ['git', 'remote', 'get-url', 'origin'],
+                        cwd=self.current_project_path,
+                        capture_output=True,
+                        text=True,
+                        timeout=5
+                    )
+                    if result.returncode == 0:
+                        git_info['remote_url'] = result.stdout.strip()
+                except Exception:
+                    pass
+                
+                # Get last commit
+                try:
+                    result = subprocess.run(
+                        ['git', 'rev-parse', 'HEAD'],
+                        cwd=self.current_project_path,
+                        capture_output=True,
+                        text=True,
+                        timeout=5
+                    )
+                    if result.returncode == 0:
+                        git_info['last_commit'] = result.stdout.strip()
+                except Exception:
+                    pass
+                
+                # Check for uncommitted changes
+                try:
+                    result = subprocess.run(
+                        ['git', 'status', '--porcelain'],
+                        cwd=self.current_project_path,
+                        capture_output=True,
+                        text=True,
+                        timeout=5
+                    )
+                    if result.returncode == 0:
+                        git_info['has_uncommitted'] = bool(result.stdout.strip())
+                except Exception:
+                    pass
+        
+        except Exception as e:
+            self.logger.debug(f"Failed to get git info: {e}")
+        
+        return git_info
+    
+    def _build_session_info(self) -> Dict[str, Any]:
+        """
+        Build session information.
+        
+        WHY: Session information tracks the current claude-mpm session state,
+        including active components and configuration. This helps with session
+        management and debugging.
+        """
+        # These would be populated by the actual session manager
+        # For now, we provide placeholders that can be updated by the caller
+        return {
+            'session_id': None,  # Could be set by session manager
+            'ticket_count': 0,   # Could be updated by ticket manager
+            'agent_count': 0,    # Could be updated by agent manager
+            'hooks_enabled': False,  # Could be detected from configuration
+            'monitor_enabled': False  # Could be detected from process state
+        }
+    
+    def _build_project_info(self) -> Dict[str, Any]:
+        """
+        Build project information section.
+        
+        WHY: Project information helps identify the type of project and its
+        characteristics, enabling better tool selection and project-specific
+        optimizations.
+        """
+        project_info = {
+            'has_claude_config': False,
+            'has_claude_md': False,
+            'has_pyproject': False,
+            'has_package_json': False,
+            'project_type': 'unknown'
+        }
+        
+        # Check for various project files
+        claude_files = ['.claude', 'claude.toml', '.claude.toml']
+        for claude_file in claude_files:
+            if (self.current_project_path / claude_file).exists():
+                project_info['has_claude_config'] = True
+                break
+        
+        claude_md_files = ['CLAUDE.md', 'claude.md', '.claude.md']
+        for claude_md in claude_md_files:
+            if (self.current_project_path / claude_md).exists():
+                project_info['has_claude_md'] = True
+                break
+        
+        if (self.current_project_path / 'pyproject.toml').exists():
+            project_info['has_pyproject'] = True
+        
+        if (self.current_project_path / 'package.json').exists():
+            project_info['has_package_json'] = True
+        
+        # Determine project type
+        if project_info['has_pyproject'] or (self.current_project_path / 'setup.py').exists():
+            project_info['project_type'] = 'python'
+        elif project_info['has_package_json']:
+            project_info['project_type'] = 'javascript'
+        elif (self.current_project_path / 'Cargo.toml').exists():
+            project_info['project_type'] = 'rust'
+        elif (self.current_project_path / 'go.mod').exists():
+            project_info['project_type'] = 'go'
+        elif (self.current_project_path / 'pom.xml').exists():
+            project_info['project_type'] = 'java'
+        elif any((self.current_project_path / ext).exists() for ext in ['*.c', '*.cpp', '*.h', '*.hpp']):
+            project_info['project_type'] = 'c/cpp'
+        elif project_info['has_claude_config'] or project_info['has_claude_md']:
+            project_info['project_type'] = 'claude'
+        else:
+            # Try to detect by file extensions
+            common_files = list(self.current_project_path.iterdir())[:20]  # Check first 20 files
+            extensions = {f.suffix.lower() for f in common_files if f.is_file()}
+            
+            if '.py' in extensions:
+                project_info['project_type'] = 'python'
+            elif any(ext in extensions for ext in ['.js', '.ts', '.jsx', '.tsx']):
+                project_info['project_type'] = 'javascript'
+            elif any(ext in extensions for ext in ['.rs']):
+                project_info['project_type'] = 'rust'
+            elif any(ext in extensions for ext in ['.go']):
+                project_info['project_type'] = 'go'
+            elif any(ext in extensions for ext in ['.java', '.scala', '.kt']):
+                project_info['project_type'] = 'jvm'
+            elif any(ext in extensions for ext in ['.c', '.cpp', '.cc', '.h', '.hpp']):
+                project_info['project_type'] = 'c/cpp'
+            elif any(ext in extensions for ext in ['.md', '.txt', '.rst']):
+                project_info['project_type'] = 'documentation'
+        
+        return project_info
+    
+    def _save_registry_data(self, registry_file: Path, data: Dict[str, Any]) -> None:
+        """
+        Save registry data to YAML file.
+        
+        WHY: Centralized saving logic ensures consistent formatting and error
+        handling across all registry operations. YAML format provides human
+        readability for debugging and manual inspection.
+        
+        Args:
+            registry_file: Path to the registry file
+            data: Registry data to save
+        """
+        try:
+            # Remove internal fields before saving
+            save_data = {k: v for k, v in data.items() if not k.startswith('_')}
+            
+            with open(registry_file, 'w', encoding='utf-8') as f:
+                yaml.dump(save_data, f, default_flow_style=False, sort_keys=False, indent=2)
+                
+            self.logger.debug(f"Saved registry data to {registry_file}")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to save registry data: {e}")
+            raise ProjectRegistryError(f"Failed to save registry: {e}")
+    
+    def list_projects(self) -> List[Dict[str, Any]]:
+        """
+        List all registered projects.
+        
+        WHY: Provides visibility into all projects managed by claude-mpm,
+        useful for project management and analytics.
+        
+        Returns:
+            List of project registry data dictionaries
+        """
+        projects = []
+        
+        try:
+            for registry_file in self.registry_dir.glob("*.yaml"):
+                try:
+                    with open(registry_file, 'r', encoding='utf-8') as f:
+                        data = yaml.safe_load(f) or {}
+                    projects.append(data)
+                except Exception as e:
+                    self.logger.warning(f"Failed to read registry file {registry_file}: {e}")
+                    continue
+        
+        except Exception as e:
+            self.logger.error(f"Failed to list projects: {e}")
+        
+        return projects
+    
+    def cleanup_old_entries(self, max_age_days: int = 90) -> int:
+        """
+        Clean up old registry entries that haven't been accessed recently.
+        
+        WHY: Prevents registry directory from growing indefinitely with old
+        project entries. Keeps the registry focused on active projects.
+        
+        Args:
+            max_age_days: Maximum age in days for keeping entries
+            
+        Returns:
+            Number of entries cleaned up
+        """
+        if max_age_days <= 0:
+            return 0
+        
+        cleaned_count = 0
+        cutoff_date = datetime.now(timezone.utc) - timedelta(days=max_age_days)
+        
+        try:
+            for registry_file in self.registry_dir.glob("*.yaml"):
+                try:
+                    with open(registry_file, 'r', encoding='utf-8') as f:
+                        data = yaml.safe_load(f) or {}
+                    
+                    # Check last accessed time
+                    last_accessed_str = data.get('metadata', {}).get('last_accessed')
+                    if last_accessed_str:
+                        last_accessed = datetime.fromisoformat(last_accessed_str.replace('Z', '+00:00'))
+                        if last_accessed < cutoff_date:
+                            registry_file.unlink()
+                            cleaned_count += 1
+                            self.logger.debug(f"Cleaned up old registry entry: {registry_file}")
+                    
+                except Exception as e:
+                    self.logger.warning(f"Failed to process registry file {registry_file}: {e}")
+                    continue
+        
+        except Exception as e:
+            self.logger.error(f"Failed to cleanup old entries: {e}")
+        
+        if cleaned_count > 0:
+            self.logger.info(f"Cleaned up {cleaned_count} old registry entries")
+        
+        return cleaned_count
+    
+    def update_session_info(self, session_updates: Dict[str, Any]) -> bool:
+        """
+        Update session information for the current project.
+        
+        WHY: Allows other components (session manager, ticket manager, etc.)
+        to update the registry with current session state information.
+        
+        Args:
+            session_updates: Dictionary of session updates to apply
+            
+        Returns:
+            True if update was successful, False otherwise
+        """
+        try:
+            existing_entry = self._find_existing_entry()
+            if not existing_entry:
+                self.logger.warning("No existing registry entry found for session update")
+                return False
+            
+            registry_file = existing_entry.get('_registry_file')
+            if not registry_file:
+                self.logger.error("Registry file reference missing")
+                return False
+            
+            # Update session information
+            if 'session' not in existing_entry:
+                existing_entry['session'] = {}
+            
+            existing_entry['session'].update(session_updates)
+            
+            # Update metadata timestamp
+            now = datetime.now(timezone.utc).isoformat()
+            existing_entry['metadata']['updated_at'] = now
+            
+            # Save updated data
+            self._save_registry_data(registry_file, existing_entry)
+            
+            self.logger.debug(f"Updated session info: {session_updates}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update session info: {e}")
+            return False

{claude_mpm-3.4.24.dist-info → claude_mpm-3.4.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.4.24
+Version: 3.4.27
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

{claude_mpm-3.4.24.dist-info → claude_mpm-3.4.27.dist-info}/RECORD

@@ -1,9 +1,9 @@
-claude_mpm/VERSION,sha256=7KsmcVU6D1htEeqmCXAzqOZqH7HnDus2dyMuTm9va8Y,6
+claude_mpm/VERSION,sha256=hhCrnKPRWgpiBU7FuephYkZuc9HC8J3tY6EJASjpJn8,7
 claude_mpm/__init__.py,sha256=ix_J0PHZBz37nVBDEYJmLpwnURlWuBKKQ8rK_00TFpk,964
 claude_mpm/__main__.py,sha256=8IcM9tEbTqSN_er04eKTPX3AGo6qzRiTnPI7KfIf7rw,641
 claude_mpm/constants.py,sha256=yOf-82f1HH6pL19dB3dWPUqU09dnXuAx3kDh3xWpc1U,4526
 claude_mpm/deployment_paths.py,sha256=JO7-fhhp_AkVB7ZssggHDBbee-r2sokpkqjoqnQLTmM,9073
-claude_mpm/init.py,sha256=gOreOf7BLXkT0_HrQk_As4Kz1OT_NJG_RG0i0hbY0z0,8088
+claude_mpm/init.py,sha256=lscRw6fKuwIcokLtaFdVh-cuTx0cZWMSMSLR3qlDJkM,8154
 claude_mpm/ticket_wrapper.py,sha256=bWjLReYyuHSBguuiRm1d52rHYNHqrPJAOLUbMt4CnuM,836
 claude_mpm/agents/BASE_AGENT_TEMPLATE.md,sha256=TYgSd9jNBMWp4mAOBUl9dconX4RcGbvmMEScRy5uyko,3343
 claude_mpm/agents/INSTRUCTIONS.md,sha256=tdekngpZ5RjECYZosOaDSBmXPZsVvZcwDQEmmlw7fOQ,14268
@@ -37,7 +37,7 @@ claude_mpm/agents/templates/backup/qa_agent_20250726_234551.json,sha256=_FHWnUeh
 claude_mpm/agents/templates/backup/research_agent_20250726_234551.json,sha256=o4n_sqSbjnsFRELB2q501vgwm-o2tQNLJLYvnVP9LWU,5629
 claude_mpm/agents/templates/backup/security_agent_20250726_234551.json,sha256=l5YuD-27CxKSOsRLv0bDY_tCZyds0yGbeizLb8paeFY,2322
 claude_mpm/agents/templates/backup/version_control_agent_20250726_234551.json,sha256=too38RPTLJ9HutCMn0nfmEdCj2me241dx5tUYDFtu94,2143
-claude_mpm/cli/__init__.py,sha256=XH1JwRjUo6o3swooSCrQiZFbR_yQFgEmWEXwY_UqGV8,5923
+claude_mpm/cli/__init__.py,sha256=CV0utQO2Zq_kDSYqsFsjOkILxMZ14MgMHj7ffLDEGHA,6958
 claude_mpm/cli/parser.py,sha256=ajdlusfbfcY44756pdrkfROEVlTaVJyEBDJup78Q-yE,18270
 claude_mpm/cli/utils.py,sha256=k_EHLcjDAzYhDeVeWvE-vqvHsEoG6Cc6Yk7fs3YoRVA,6022
 claude_mpm/cli/commands/__init__.py,sha256=kUtBjfTYZnfAL_4QEPCBtFg2nWgJ2cxCPzIIsiFURXM,567
@@ -158,6 +158,7 @@ claude_mpm/services/memory_builder.py,sha256=Y_Gx0IIJhGjUx1NAjslC1MFPbRaXuoRdkQX
 claude_mpm/services/memory_optimizer.py,sha256=uydUqx0Nd3ib7KNfKnlR9tPW5MLSUC5OAJg0GH2Jj4E,23638
 claude_mpm/services/memory_router.py,sha256=oki6D2ma1KWdgP6uSfu8xvLzRpk-k3PGw6CO5XDMGPY,22504
 claude_mpm/services/project_analyzer.py,sha256=3Ub_Tpcxm0LnYgcAipebvWr6TfofVqZNMkANejA2C44,33564
+claude_mpm/services/project_registry.py,sha256=1LRO6LsKvrVa4xkNyDb4rMDN8LXElAgIqhI7DoUjChI,24176
 claude_mpm/services/recovery_manager.py,sha256=K46vXbEWbxFUoS42s34OxN1rkddpisGG7E_ZdRyAZ-A,25792
 claude_mpm/services/shared_prompt_cache.py,sha256=D04lrRWyg0lHyqGcAHy7IYvRHRKSg6EOpAJwBUPa2wk,29890
 claude_mpm/services/socketio_client_manager.py,sha256=2Ly63iiGA_BUzf73UwQDu9Q75wA1C4O1CWFv8hi8bms,18074
@@ -215,9 +216,9 @@ claude_mpm/utils/path_operations.py,sha256=6pLMnAWBVzHkgp6JyQHmHbGD-dWn-nX21yV4E
 claude_mpm/utils/paths.py,sha256=Xv0SZWdZRkRjN9e6clBcA165ya00GNQxt7SwMz51tfA,10153
 claude_mpm/validation/__init__.py,sha256=bJ19g9lnk7yIjtxzN8XPegp87HTFBzCrGQOpFgRTf3g,155
 claude_mpm/validation/agent_validator.py,sha256=GCA2b2rKhKDeaNyUqWxTiWIs3sDdWjD9cgOFRp9K6ic,18227
-claude_mpm-3.4.24.dist-info/licenses/LICENSE,sha256=cSdDfXjoTVhstrERrqme4zgxAu4GubU22zVEHsiXGxs,1071
-claude_mpm-3.4.24.dist-info/METADATA,sha256=TtPlPX8ZHAVNvt6X7F4RkCx3AL7qrtGhbccpuevbExE,6527
-claude_mpm-3.4.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-3.4.24.dist-info/entry_points.txt,sha256=3_d7wLrg9sRmQ1SfrFGWoTNL8Wrd6lQb2XVSYbTwRIg,324
-claude_mpm-3.4.24.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-3.4.24.dist-info/RECORD,,
+claude_mpm-3.4.27.dist-info/licenses/LICENSE,sha256=cSdDfXjoTVhstrERrqme4zgxAu4GubU22zVEHsiXGxs,1071
+claude_mpm-3.4.27.dist-info/METADATA,sha256=1_Yq8G2LAPn07vwi_EOAJAf8q50f5pm5P9ZJnKRp28M,6527
+claude_mpm-3.4.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-3.4.27.dist-info/entry_points.txt,sha256=3_d7wLrg9sRmQ1SfrFGWoTNL8Wrd6lQb2XVSYbTwRIg,324
+claude_mpm-3.4.27.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-3.4.27.dist-info/RECORD,,