claude-mpm 3.9.2__py3-none-any.whl → 3.9.4__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-3.9.2
+3.9.4

claude_mpm/config/paths.py

@@ -33,6 +33,7 @@ class ClaudeMPMPaths:
     
     _instance: Optional['ClaudeMPMPaths'] = None
     _project_root: Optional[Path] = None
+    _is_installed: bool = False
     
     def __new__(cls) -> 'ClaudeMPMPaths':
         """Singleton pattern to ensure single instance."""
@@ -43,6 +44,7 @@ class ClaudeMPMPaths:
     def __init__(self):
         """Initialize paths if not already done."""
         if self._project_root is None:
+            self._is_installed = False
             self._detect_project_root()
     
     def _detect_project_root(self) -> None:
@@ -53,16 +55,29 @@ class ClaudeMPMPaths:
         1. Look for definitive project markers (pyproject.toml, setup.py)
         2. Look for combination of markers to ensure we're at the right level
         3. Walk up from current file location
+        4. Handle both development and installed environments
         """
         # Start from this file's location
         current = Path(__file__).resolve()
         
-        # Walk up the directory tree
+        # Check if we're in an installed environment (site-packages)
+        # In pip/pipx installs, the package is directly in site-packages
+        if 'site-packages' in str(current) or 'dist-packages' in str(current):
+            # We're in an installed environment
+            # The claude_mpm package directory itself is the "root" for resources
+            import claude_mpm
+            self._project_root = Path(claude_mpm.__file__).parent
+            self._is_installed = True
+            logger.debug(f"Installed environment detected, using package dir: {self._project_root}")
+            return
+        
+        # We're in a development environment, look for project markers
         for parent in current.parents:
             # Check for definitive project root indicators
             # Prioritize pyproject.toml and setup.py as they're only at root
             if (parent / 'pyproject.toml').exists() or (parent / 'setup.py').exists():
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (found pyproject.toml or setup.py)")
                 return
             
@@ -70,6 +85,7 @@ class ClaudeMPMPaths:
             # This combination is more likely to be the real project root
             if (parent / '.git').exists() and (parent / 'VERSION').exists():
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (found .git and VERSION)")
                 return
         
@@ -77,12 +93,14 @@ class ClaudeMPMPaths:
         for parent in current.parents:
             if parent.name == 'claude-mpm':
                 self._project_root = parent
+                self._is_installed = False
                 logger.debug(f"Project root detected at: {parent} (by directory name)")
                 return
         
         # Last resort fallback: 3 levels up from this file
         # paths.py is in src/claude_mpm/config/
         self._project_root = current.parent.parent.parent
+        self._is_installed = False
         logger.warning(f"Project root fallback to: {self._project_root}")
     
     @property
@@ -95,16 +113,26 @@ class ClaudeMPMPaths:
     @property
     def src_dir(self) -> Path:
         """Get the src directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, there's no src directory
+            # Return the package directory itself
+            return self.project_root.parent
         return self.project_root / "src"
     
     @property
     def claude_mpm_dir(self) -> Path:
         """Get the main claude_mpm package directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, project_root IS the claude_mpm directory
+            return self.project_root
         return self.src_dir / "claude_mpm"
     
     @property
     def agents_dir(self) -> Path:
         """Get the agents directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, agents is directly under the package
+            return self.project_root / "agents"
         return self.claude_mpm_dir / "agents"
     
     @property
@@ -140,36 +168,58 @@ class ClaudeMPMPaths:
     @property
     def scripts_dir(self) -> Path:
         """Get the scripts directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # In installed environment, scripts might be in a different location or not exist
+            # Return a path that won't cause issues but indicates it's not available
+            return Path.home() / '.claude-mpm' / 'scripts'
         return self.project_root / "scripts"
     
     @property
     def tests_dir(self) -> Path:
         """Get the tests directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Tests aren't distributed with installed packages
+            return Path.home() / '.claude-mpm' / 'tests'
         return self.project_root / "tests"
     
     @property
     def docs_dir(self) -> Path:
         """Get the documentation directory."""
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Docs might be installed separately or not at all
+            return Path.home() / '.claude-mpm' / 'docs'
         return self.project_root / "docs"
     
     @property
     def logs_dir(self) -> Path:
         """Get the logs directory (creates if doesn't exist)."""
-        logs = self.project_root / "logs"
-        logs.mkdir(exist_ok=True)
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use user's home directory for logs in installed environment
+            logs = Path.home() / '.claude-mpm' / 'logs'
+        else:
+            logs = self.project_root / "logs"
+        logs.mkdir(parents=True, exist_ok=True)
         return logs
     
     @property
     def temp_dir(self) -> Path:
         """Get the temporary files directory (creates if doesn't exist)."""
-        temp = self.project_root / ".tmp"
-        temp.mkdir(exist_ok=True)
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use user's home directory for temp files in installed environment
+            temp = Path.home() / '.claude-mpm' / '.tmp'
+        else:
+            temp = self.project_root / ".tmp"
+        temp.mkdir(parents=True, exist_ok=True)
         return temp
     
     @property
     def claude_mpm_dir_hidden(self) -> Path:
         """Get the hidden .claude-mpm directory (creates if doesn't exist)."""
-        hidden = self.project_root / ".claude-mpm"
+        if hasattr(self, '_is_installed') and self._is_installed:
+            # Use current working directory in installed environment
+            hidden = Path.cwd() / ".claude-mpm"
+        else:
+            hidden = self.project_root / ".claude-mpm"
         hidden.mkdir(exist_ok=True)
         return hidden
     

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -21,6 +21,7 @@ import time
 import asyncio
 from pathlib import Path
 from collections import deque
+import threading
 
 # Import constants for configuration
 try:
@@ -87,6 +88,102 @@ except ImportError:
 # No fallback needed - we only use Socket.IO now
 
 
+
+class SocketIOConnectionPool:
+    """Connection pool for Socket.IO clients to prevent connection leaks."""
+    
+    def __init__(self, max_connections=3):
+        self.max_connections = max_connections
+        self.connections = []
+        self.last_cleanup = time.time()
+        
+    def get_connection(self, port):
+        """Get or create a connection to the specified port."""
+        if time.time() - self.last_cleanup > 60:
+            self._cleanup_dead_connections()
+            self.last_cleanup = time.time()
+        
+        for conn in self.connections:
+            if conn.get('port') == port and conn.get('client'):
+                client = conn['client']
+                if self._is_connection_alive(client):
+                    return client
+                else:
+                    self.connections.remove(conn)
+        
+        if len(self.connections) < self.max_connections:
+            client = self._create_connection(port)
+            if client:
+                self.connections.append({
+                    'port': port,
+                    'client': client,
+                    'created': time.time()
+                })
+                return client
+        
+        if self.connections:
+            oldest = min(self.connections, key=lambda x: x['created'])
+            self._close_connection(oldest['client'])
+            oldest['client'] = self._create_connection(port)
+            oldest['port'] = port
+            oldest['created'] = time.time()
+            return oldest['client']
+        
+        return None
+    
+    def _create_connection(self, port):
+        """Create a new Socket.IO connection."""
+        if not SOCKETIO_AVAILABLE:
+            return None
+        try:
+            client = socketio.Client(
+                reconnection=False,  # Disable auto-reconnect
+                logger=False,
+                engineio_logger=False
+            )
+            client.connect(f'http://localhost:{port}', 
+                          wait=True, 
+                          wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT)
+            if client.connected:
+                return client
+        except Exception:
+            pass
+        return None
+    
+    def _is_connection_alive(self, client):
+        """Check if a connection is still alive."""
+        try:
+            return client and client.connected
+        except:
+            return False
+    
+    def _close_connection(self, client):
+        """Safely close a connection."""
+        try:
+            if client:
+                client.disconnect()
+        except:
+            pass
+    
+    def _cleanup_dead_connections(self):
+        """Remove dead connections from the pool."""
+        self.connections = [
+            conn for conn in self.connections 
+            if self._is_connection_alive(conn.get('client'))
+        ]
+    
+    def close_all(self):
+        """Close all connections in the pool."""
+        for conn in self.connections:
+            self._close_connection(conn.get('client'))
+        self.connections.clear()
+
+
+# Global singleton handler instance
+_global_handler = None
+_handler_lock = threading.Lock()
+
+
 class ClaudeHookHandler:
     """Optimized hook handler with direct Socket.IO client.
     
@@ -99,8 +196,17 @@ class ClaudeHookHandler:
     
     def __init__(self):
         # Socket.IO client (persistent if possible)
-        self.sio_client = None
-        self.sio_connected = False
+        self.connection_pool = SocketIOConnectionPool(max_connections=3)
+        # Track events for periodic cleanup
+        self.events_processed = 0
+        self.last_cleanup = time.time()
+        
+        # Maximum sizes for tracking
+        self.MAX_DELEGATION_TRACKING = 200
+        self.MAX_PROMPT_TRACKING = 100
+        self.MAX_CACHE_AGE_SECONDS = 300
+        self.CLEANUP_INTERVAL_EVENTS = 100
+
         
         # Agent delegation tracking
         # Store recent Task delegations: session_id -> agent_type
@@ -179,6 +285,36 @@ class ClaudeHookHandler:
                 if key in self.delegation_requests:
                     del self.delegation_requests[key]
     
+    
+    def _cleanup_old_entries(self):
+        """Clean up old entries to prevent memory growth."""
+        cutoff_time = datetime.now().timestamp() - self.MAX_CACHE_AGE_SECONDS
+        
+        # Clean up delegation tracking dictionaries
+        for storage in [self.active_delegations, self.delegation_requests]:
+            if len(storage) > self.MAX_DELEGATION_TRACKING:
+                # Keep only the most recent entries
+                sorted_keys = sorted(storage.keys())
+                excess = len(storage) - self.MAX_DELEGATION_TRACKING
+                for key in sorted_keys[:excess]:
+                    del storage[key]
+        
+        # Clean up pending prompts
+        if len(self.pending_prompts) > self.MAX_PROMPT_TRACKING:
+            sorted_keys = sorted(self.pending_prompts.keys())
+            excess = len(self.pending_prompts) - self.MAX_PROMPT_TRACKING
+            for key in sorted_keys[:excess]:
+                del self.pending_prompts[key]
+        
+        # Clean up git branch cache
+        expired_keys = [
+            key for key, cache_time in self._git_branch_cache_time.items()
+            if datetime.now().timestamp() - cache_time > self.MAX_CACHE_AGE_SECONDS
+        ]
+        for key in expired_keys:
+            self._git_branch_cache.pop(key, None)
+            self._git_branch_cache_time.pop(key, None)
+
     def _get_delegation_agent_type(self, session_id: str) -> str:
         """Get the agent type for a session's active delegation."""
         # First try exact session match
@@ -455,97 +591,6 @@ class ClaudeHookHandler:
             self._git_branch_cache_time[cache_key] = current_time
             return 'Unknown'
     
-    def _get_socketio_client(self):
-        """Get or create Socket.IO client with improved reliability.
-        
-        WHY improved approach:
-        - Implements retry logic with exponential backoff
-        - Properly tests connection before returning
-        - Ensures connection persists across events
-        - Better error handling and recovery
-        """
-        if not SOCKETIO_AVAILABLE:
-            return None
-            
-        # Check if we have a connected client
-        if self.sio_client and self.sio_connected:
-            try:
-                # Test if still connected
-                if self.sio_client.connected:
-                    return self.sio_client
-                else:
-                    # Connection lost, clear it
-                    if DEBUG:
-                        print("Hook handler: Socket.IO connection lost, reconnecting...", file=sys.stderr)
-                    self.sio_connected = False
-            except:
-                self.sio_connected = False
-        
-        # Need to create or reconnect client
-        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
-        max_retries = RetryConfig.MAX_RETRIES
-        retry_delay = RetryConfig.INITIAL_RETRY_DELAY
-        
-        for attempt in range(max_retries):
-            try:
-                # Clean up old client if exists
-                if self.sio_client and not self.sio_connected:
-                    try:
-                        self.sio_client.disconnect()
-                    except:
-                        pass
-                    self.sio_client = None
-                
-                # Create new client
-                self.sio_client = socketio.Client(
-                    reconnection=True,  # Enable auto-reconnection
-                    reconnection_attempts=3,
-                    reconnection_delay=NetworkConfig.RECONNECTION_DELAY,
-                    reconnection_delay_max=2,
-                    logger=False,
-                    engineio_logger=False
-                )
-                
-                # Try to connect with proper wait
-                self.sio_client.connect(
-                    f'http://localhost:{port}', 
-                    wait=True, 
-                    wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT
-                )
-                
-                # Verify connection
-                if self.sio_client.connected:
-                    self.sio_connected = True
-                    if DEBUG:
-                        print(f"Hook handler: Successfully connected to Socket.IO server on port {port} (attempt {attempt + 1})", file=sys.stderr)
-                    return self.sio_client
-                    
-            except Exception as e:
-                if DEBUG and attempt == max_retries - 1:
-                    print(f"Hook handler: Failed to connect to Socket.IO after {max_retries} attempts: {e}", file=sys.stderr)
-                elif DEBUG:
-                    print(f"Hook handler: Connection attempt {attempt + 1} failed, retrying...", file=sys.stderr)
-                
-                # Exponential backoff with async delay
-                if attempt < max_retries - 1:
-                    # Use asyncio.sleep if in async context, otherwise fall back to time.sleep
-                    try:
-                        loop = asyncio.get_event_loop()
-                        if loop.is_running():
-                            # We're in an async context, use async sleep
-                            asyncio.create_task(asyncio.sleep(retry_delay))
-                        else:
-                            # Sync context, use regular sleep
-                            time.sleep(retry_delay)
-                    except:
-                        # Fallback to sync sleep if asyncio not available
-                        time.sleep(retry_delay)
-                    retry_delay *= 2  # Double the delay for next attempt
-        
-        # All attempts failed
-        self.sio_client = None
-        self.sio_connected = False
-        return None
     
     def handle(self):
         """Process hook event with minimal overhead and zero blocking delays.
@@ -565,6 +610,13 @@ class ClaudeHookHandler:
                 self._continue_execution()
                 return
             
+            # Increment event counter and perform periodic cleanup
+            self.events_processed += 1
+            if self.events_processed % self.CLEANUP_INTERVAL_EVENTS == 0:
+                self._cleanup_old_entries()
+                if DEBUG:
+                    print(f"🧹 Performed cleanup after {self.events_processed} events", file=sys.stderr)
+            
             # Route event to appropriate handler
             self._route_event(event)
             
@@ -647,7 +699,8 @@ class ClaudeHookHandler:
         # The daemon should be running when manager is active
         
         # Get Socket.IO client
-        client = self._get_socketio_client()
+        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+        client = self.connection_pool.get_connection(port)
         if not client:
             if DEBUG:
                 print(f"Hook handler: No Socket.IO client available for event: hook.{event}", file=sys.stderr)
@@ -680,22 +733,18 @@ class ClaudeHookHandler:
                     print(f"✅ Successfully emitted Socket.IO event: hook.{event}", file=sys.stderr)
                 else:
                     print(f"⚠️ Event emitted but connection status uncertain: hook.{event}", file=sys.stderr)
-                    self.sio_connected = False  # Force reconnection next time
                     
         except Exception as e:
             if DEBUG:
                 print(f"❌ Socket.IO emit failed for hook.{event}: {e}", file=sys.stderr)
-            # Mark as disconnected so next call will reconnect
-            self.sio_connected = False
             
             # Try to reconnect immediately for critical events
             if event in ['subagent_stop', 'pre_tool']:
                 if DEBUG:
                     print(f"Hook handler: Attempting immediate reconnection for critical event: hook.{event}", file=sys.stderr)
-                # Clear the client to force reconnection
-                self.sio_client = None
                 # Try to get a new client and emit again
-                retry_client = self._get_socketio_client()
+                retry_port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+                retry_client = self.connection_pool.get_connection(retry_port)
                 if retry_client:
                     try:
                         retry_client.emit('claude_event', claude_event_data)
@@ -1667,18 +1716,31 @@ class ClaudeHookHandler:
             # Don't fail the delegation result - memory is optional
     
     def __del__(self):
-        """Cleanup Socket.IO client on handler destruction."""
-        if self.sio_client and self.sio_connected:
+        """Cleanup Socket.IO connections on handler destruction."""
+        if hasattr(self, 'connection_pool') and self.connection_pool:
             try:
-                self.sio_client.disconnect()
+                self.connection_pool.close_all()
             except:
                 pass
 
 
 def main():
-    """Entry point with comprehensive error handling."""
+    """Entry point with singleton pattern to prevent multiple instances."""
+    global _global_handler
+    
     try:
-        handler = ClaudeHookHandler()
+        # Use singleton pattern to prevent creating multiple instances
+        with _handler_lock:
+            if _global_handler is None:
+                _global_handler = ClaudeHookHandler()
+                if DEBUG:
+                    print(f"✅ Created new ClaudeHookHandler singleton (pid: {os.getpid()})", file=sys.stderr)
+            else:
+                if DEBUG:
+                    print(f"♻️ Reusing existing ClaudeHookHandler singleton (pid: {os.getpid()})", file=sys.stderr)
+            
+            handler = _global_handler
+        
         handler.handle()
     except Exception as e:
         # Always output continue action to not block Claude

claude_mpm/utils/paths.py

@@ -5,6 +5,7 @@ to avoid duplication across the codebase.
 """
 
 import os
+import sys
 from pathlib import Path
 from typing import Optional, Union, List
 from functools import lru_cache
@@ -45,11 +46,17 @@ class PathResolver:
         try:
             import claude_mpm
             module_path = Path(claude_mpm.__file__).parent
-            # Go up to find the src directory, then one more for root
+            
+            # Check if we're in a development environment (has src/ directory)
             if module_path.parent.name == 'src':
+                # Development structure: project_root/src/claude_mpm/
                 return module_path.parent.parent
-            # Otherwise, assume we're in site-packages
+            
+            # Check if we're in an installed environment (site-packages)
+            # In this case, the module itself IS the framework root for resources
+            # No src/ directory exists in installed packages
             return module_path
+            
         except ImportError:
             pass
         
@@ -78,22 +85,50 @@ class PathResolver:
         Raises:
             FileNotFoundError: If agents directory doesn't exist
         """
+        # Try using importlib.resources first (Python 3.9+)
+        try:
+            if sys.version_info >= (3, 9):
+                from importlib.resources import files
+                agents_path = files('claude_mpm').joinpath('agents')
+                if agents_path.exists():
+                    return Path(str(agents_path))
+            else:
+                # For Python 3.7-3.8, use the backport approach
+                from importlib import resources
+                with resources.path('claude_mpm', 'agents') as agents_path:
+                    if agents_path.exists():
+                        return agents_path
+        except (ImportError, ModuleNotFoundError, TypeError):
+            # Fall back to manual detection if importlib.resources fails
+            pass
+        
+        # Fallback to manual detection
         framework_root = cls.get_framework_root()
         
-        # Check for development structure
-        agents_dir = framework_root / 'src' / 'claude_mpm' / 'agents'
+        # First check if we're in development structure (framework_root is project root)
+        # This happens when framework_root has a src/ directory
+        if (framework_root / 'src').exists():
+            agents_dir = framework_root / 'src' / 'claude_mpm' / 'agents'
+            if agents_dir.exists():
+                return agents_dir
+        
+        # Otherwise we're in installed structure (framework_root is claude_mpm package)
+        # In pip/pipx installs, framework_root already points to claude_mpm package
+        agents_dir = framework_root / 'agents'
         if agents_dir.exists():
             return agents_dir
         
-        # Check for installed structure
+        # Last fallback for edge cases
         agents_dir = framework_root / 'claude_mpm' / 'agents'
         if agents_dir.exists():
             return agents_dir
         
         raise FileNotFoundError(
             f"Agents directory not found. Searched in:\n"
-            f"  - {framework_root / 'src' / 'claude_mpm' / 'agents'}\n"
-            f"  - {framework_root / 'claude_mpm' / 'agents'}"
+            f"  - importlib.resources lookup\n"
+            f"  - {framework_root / 'src' / 'claude_mpm' / 'agents'} (development)\n"
+            f"  - {framework_root / 'agents'} (installed)\n"
+            f"  - {framework_root / 'claude_mpm' / 'agents'} (fallback)"
         )
     
     @classmethod
@@ -260,6 +295,70 @@ class PathResolver:
         logger.debug(f"Found {len(matches)} files matching '{pattern}' in {root}")
         return matches
     
+    @classmethod
+    def get_package_resource_path(cls, resource_path: str) -> Path:
+        """Get the path to a resource within the claude_mpm package.
+        
+        This method handles both development and installed environments correctly.
+        
+        Args:
+            resource_path: Relative path within the claude_mpm package (e.g., 'agents/templates')
+            
+        Returns:
+            Path: Full path to the resource
+            
+        Raises:
+            FileNotFoundError: If the resource doesn't exist
+        """
+        # Try using importlib.resources first (most reliable for installed packages)
+        try:
+            if sys.version_info >= (3, 9):
+                from importlib.resources import files
+                resource = files('claude_mpm').joinpath(resource_path)
+                if resource.exists():
+                    return Path(str(resource))
+            else:
+                # For Python 3.7-3.8
+                from importlib import resources
+                parts = resource_path.split('/')
+                if len(parts) == 1:
+                    with resources.path('claude_mpm', parts[0]) as p:
+                        if p.exists():
+                            return p
+                else:
+                    # For nested paths, navigate step by step
+                    package = 'claude_mpm'
+                    for part in parts[:-1]:
+                        package = f"{package}.{part}"
+                    with resources.path(package, parts[-1]) as p:
+                        if p.exists():
+                            return p
+        except (ImportError, ModuleNotFoundError, TypeError, AttributeError):
+            # Fall back to file system detection
+            pass
+        
+        # Fallback: Use file system detection
+        import claude_mpm
+        module_path = Path(claude_mpm.__file__).parent
+        resource = module_path / resource_path
+        
+        if resource.exists():
+            return resource
+        
+        # Try with framework root
+        framework_root = cls.get_framework_root()
+        if (framework_root / 'src').exists():
+            # Development environment
+            resource = framework_root / 'src' / 'claude_mpm' / resource_path
+        else:
+            # Installed environment
+            resource = framework_root / resource_path
+        
+        if resource.exists():
+            return resource
+        
+        raise FileNotFoundError(f"Resource not found: {resource_path}")
+    
     @classmethod
     def clear_cache(cls):
         """Clear all cached path lookups.
@@ -288,4 +387,9 @@ def get_project_root() -> Path:
 
 def find_file_upwards(filename: str, start_path: Optional[Path] = None) -> Optional[Path]:
     """Search for a file by traversing up the directory tree."""
-    return PathResolver.find_file_upwards(filename, start_path)
+    return PathResolver.find_file_upwards(filename, start_path)
+
+
+def get_package_resource_path(resource_path: str) -> Path:
+    """Get the path to a resource within the claude_mpm package."""
+    return PathResolver.get_package_resource_path(resource_path)

{claude_mpm-3.9.2.dist-info → claude_mpm-3.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.9.2
+Version: 3.9.4
 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.9.2.dist-info → claude_mpm-3.9.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-claude_mpm/VERSION,sha256=Lp-hVg19xAjkKCXIkTP803_6PSp9P5Eash7GshrXbNg,6
+claude_mpm/VERSION,sha256=qncwOqyY7d82tgxVa7TxJStIKb52qA2UhTpaLs0fB2Y,6
 claude_mpm/__init__.py,sha256=ix_J0PHZBz37nVBDEYJmLpwnURlWuBKKQ8rK_00TFpk,964
 claude_mpm/__main__.py,sha256=8IcM9tEbTqSN_er04eKTPX3AGo6qzRiTnPI7KfIf7rw,641
 claude_mpm/constants.py,sha256=xdYTQfOdrnp_fp2A-P4gA68X-XMq29cCwF6Xdwg3oQE,5217
@@ -69,7 +69,7 @@ claude_mpm/cli_module/commands.py,sha256=CBNfO-bXrZ0spjeW_7-swprEq5V4PQSc0qhl9SL
 claude_mpm/cli_module/migration_example.py,sha256=C-_GbsW8dGzutnNeRLLld74ibDLyAOQx0stdpYZS0hs,6137
 claude_mpm/config/__init__.py,sha256=KTJkOHVtC1t6goMkj2xaQWZKZfokEHNw0wxPE48bl1g,828
 claude_mpm/config/agent_config.py,sha256=QS-25LSiNz4uOocjIM_FX_SGoRQHJOfkBZCKlz09K5k,13830
-claude_mpm/config/paths.py,sha256=bOxSLNPBDQ3GM4NupY4Z0Jrxykgtw40z92Ytc-LMCuo,9670
+claude_mpm/config/paths.py,sha256=MznUhL7kvpOhwqtNdOavEE1JvUauvfIN_8PUXl8MytU,12553
 claude_mpm/config/socketio_config.py,sha256=rf5XKtdAKeypwZZPF8r6uSHnJHVXeMmX1YiYQmzUOZo,9727
 claude_mpm/core/__init__.py,sha256=5Hdb4fLdMEqXdOeBJB0zFGJx8CxtaSRYIiD-foiz3yQ,874
 claude_mpm/core/agent_name_normalizer.py,sha256=-X68oz3_74t9BRbHA54NEGyjy0xjTsGp_sCUHDtKp1s,9269
@@ -135,7 +135,7 @@ claude_mpm/hooks/memory_integration_hook.py,sha256=z0I5R4rsmLx3mzYf7QLeMTYbRShag
 claude_mpm/hooks/tool_call_interceptor.py,sha256=08_Odgm6Sg1zBJhGjwzVa03AReeBPZHTjndyjEO99cY,7629
 claude_mpm/hooks/validation_hooks.py,sha256=7TU2N4SzCm2nwpsR0xiNKsHQNsWODnOVAmK9jHq1QqM,6582
 claude_mpm/hooks/claude_hooks/__init__.py,sha256=bMUwt2RzDGAcEbtDMA7vWS1uJsauOY0OixIe4pHwgQ0,129
-claude_mpm/hooks/claude_hooks/hook_handler.py,sha256=3Y1zqQVn8a3WfsQN9CUYX3Ay4fvVEFuM8ErkGNwsIv4,78067
+claude_mpm/hooks/claude_hooks/hook_handler.py,sha256=hMJRlFIpYtl3SGDMseS1_kiXMrzm_w1mFG-oqU5hJ8Q,79765
 claude_mpm/hooks/claude_hooks/hook_handler_fixed.py,sha256=hYE5Tc4RaaK0kLmFNLVXvDhiuTLA40Gt3hmhCQUO5UA,15626
 claude_mpm/hooks/claude_hooks/hook_wrapper.sh,sha256=JBbedWNs1EHaUsAkmqfPv_tWxV_DcRP707hma74oHU0,2370
 claude_mpm/models/__init__.py,sha256=vy2NLX2KT9QeH76SjCYh9dOYKPLRgxGrnwkQFAg08gc,465
@@ -254,15 +254,15 @@ claude_mpm/utils/framework_detection.py,sha256=nzs1qRZK9K-zT0382z1FpGDvgzUNrUg8r
 claude_mpm/utils/import_migration_example.py,sha256=W4a4XH3FY_VBB00BB8Lae2aRPM021PxLHzdUfEs0B5w,2463
 claude_mpm/utils/imports.py,sha256=wX-SOXUHbemx01MHRGQpVwajzXH6qYdQkYNFCIbb2mw,6851
 claude_mpm/utils/path_operations.py,sha256=6pLMnAWBVzHkgp6JyQHmHbGD-dWn-nX21yV4E_eT-kM,11614
-claude_mpm/utils/paths.py,sha256=DlkYrIVvfgyuF9cN01cWuxehK0UUsCfjp6ymrv8XY7A,10253
+claude_mpm/utils/paths.py,sha256=_4d2uV7QDLMeybSNch6B5H3s0cQ6Ii-idI8rFC-OCn4,14653
 claude_mpm/utils/robust_installer.py,sha256=5-iW4Qpba4DBitx5Ie3uoUJgXBpbvuLUJ_uNGgOxwi4,19855
 claude_mpm/utils/session_logging.py,sha256=9G0AzB7V0WkhLQlN0ocqbyDv0ifooEsJ5UPXIhA-wt0,3022
 claude_mpm/validation/__init__.py,sha256=bJ19g9lnk7yIjtxzN8XPegp87HTFBzCrGQOpFgRTf3g,155
 claude_mpm/validation/agent_validator.py,sha256=OEYhmy0K99pkoCCoVea2Q-d1JMiDyhEpzEJikuF8T-U,20910
 claude_mpm/validation/frontmatter_validator.py,sha256=vSinu0XD9-31h0-ePYiYivBbxTZEanhymLinTCODr7k,7206
-claude_mpm-3.9.2.dist-info/licenses/LICENSE,sha256=cSdDfXjoTVhstrERrqme4zgxAu4GubU22zVEHsiXGxs,1071
-claude_mpm-3.9.2.dist-info/METADATA,sha256=tIZiK1xnv3isCCDqSJ33dq_7NmjLfyrq8JkwoubpTtc,8680
-claude_mpm-3.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-3.9.2.dist-info/entry_points.txt,sha256=3_d7wLrg9sRmQ1SfrFGWoTNL8Wrd6lQb2XVSYbTwRIg,324
-claude_mpm-3.9.2.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-3.9.2.dist-info/RECORD,,
+claude_mpm-3.9.4.dist-info/licenses/LICENSE,sha256=cSdDfXjoTVhstrERrqme4zgxAu4GubU22zVEHsiXGxs,1071
+claude_mpm-3.9.4.dist-info/METADATA,sha256=_rGegraOba_N2dJxC3RuA0Y34dl5raiQVaxdnyNeq0g,8680
+claude_mpm-3.9.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-3.9.4.dist-info/entry_points.txt,sha256=3_d7wLrg9sRmQ1SfrFGWoTNL8Wrd6lQb2XVSYbTwRIg,324
+claude_mpm-3.9.4.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-3.9.4.dist-info/RECORD,,