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

claude_mpm/hooks/claude_hooks/hook_handler_fixed.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+"""Optimized Claude Code hook handler with fixed memory management.
+
+MEMORY LEAK FIXES:
+1. Use singleton pattern for ClaudeHookHandler to prevent multiple instances
+2. Proper cleanup of Socket.IO connections with connection pooling
+3. Bounded dictionaries with automatic cleanup of old entries
+4. Improved git branch cache with proper expiration
+5. Better resource management and connection reuse
+
+WHY these fixes:
+- Singleton pattern ensures only one handler instance exists
+- Connection pooling prevents creating new connections for each event
+- Bounded dictionaries prevent unbounded memory growth
+- Regular cleanup prevents accumulation of stale data
+"""
+
+import json
+import sys
+import os
+import subprocess
+from datetime import datetime, timedelta
+import time
+import asyncio
+from pathlib import Path
+from collections import deque
+import weakref
+import gc
+
+# Import constants for configuration
+try:
+    from claude_mpm.core.constants import (
+        NetworkConfig,
+        TimeoutConfig,
+        RetryConfig
+    )
+except ImportError:
+    # Fallback values if constants module not available
+    class NetworkConfig:
+        SOCKETIO_PORT_RANGE = (8080, 8099)
+        RECONNECTION_DELAY = 0.5
+        SOCKET_WAIT_TIMEOUT = 1.0
+    class TimeoutConfig:
+        QUICK_TIMEOUT = 2.0
+        QUEUE_GET_TIMEOUT = 1.0
+    class RetryConfig:
+        MAX_RETRIES = 3
+        INITIAL_RETRY_DELAY = 0.1
+
+# Debug mode is enabled by default for better visibility into hook processing
+DEBUG = os.environ.get('CLAUDE_MPM_HOOK_DEBUG', 'true').lower() != 'false'
+
+# Socket.IO import
+try:
+    import socketio
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+# Memory hooks and response tracking imports (simplified)
+MEMORY_HOOKS_AVAILABLE = False
+RESPONSE_TRACKING_AVAILABLE = False
+
+# Maximum size for tracking dictionaries to prevent unbounded growth
+MAX_DELEGATION_TRACKING = 100
+MAX_PROMPT_TRACKING = 50
+MAX_CACHE_AGE_SECONDS = 300  # 5 minutes
+CLEANUP_INTERVAL_EVENTS = 100  # Clean up every 100 events
+
+
+class SocketIOConnectionPool:
+    """Connection pool for Socket.IO clients to prevent connection leaks.
+    
+    WHY: Reuses connections instead of creating new ones for each event,
+    preventing the accumulation of zombie connections over time.
+    """
+    
+    def __init__(self, max_connections=3):
+        self.max_connections = max_connections
+        self.connections = []
+        self.current_index = 0
+        self.last_cleanup = time.time()
+        
+    def get_connection(self, port):
+        """Get or create a connection to the specified port."""
+        # Clean up dead connections periodically
+        if time.time() - self.last_cleanup > 60:  # Every minute
+            self._cleanup_dead_connections()
+            self.last_cleanup = time.time()
+        
+        # Look for existing connection to this port
+        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:
+                    # Remove dead connection
+                    self.connections.remove(conn)
+        
+        # Create new connection if under limit
+        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
+        
+        # Reuse oldest connection if at limit
+        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 to prevent zombies
+                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()
+
+
+class BoundedDict(dict):
+    """Dictionary with maximum size that removes oldest entries.
+    
+    WHY: Prevents unbounded memory growth by automatically removing
+    old entries when the size limit is reached.
+    """
+    
+    def __init__(self, max_size=100):
+        super().__init__()
+        self.max_size = max_size
+        self.access_times = {}
+        
+    def __setitem__(self, key, value):
+        # Remove oldest entries if at capacity
+        if len(self) >= self.max_size and key not in self:
+            # Find and remove the oldest entry
+            if self.access_times:
+                oldest_key = min(self.access_times, key=self.access_times.get)
+                del self[oldest_key]
+                del self.access_times[oldest_key]
+        
+        super().__setitem__(key, value)
+        self.access_times[key] = time.time()
+    
+    def __delitem__(self, key):
+        super().__delitem__(key)
+        self.access_times.pop(key, None)
+    
+    def cleanup_old_entries(self, max_age_seconds=300):
+        """Remove entries older than specified age."""
+        current_time = time.time()
+        keys_to_remove = [
+            key for key, access_time in self.access_times.items()
+            if current_time - access_time > max_age_seconds
+        ]
+        for key in keys_to_remove:
+            del self[key]
+
+
+class ClaudeHookHandler:
+    """Optimized hook handler with proper memory management.
+    
+    FIXES:
+    - Uses connection pooling for Socket.IO clients
+    - Bounded dictionaries prevent unbounded growth
+    - Regular cleanup of old entries
+    - Proper cache expiration
+    """
+    
+    # Class-level singleton instance
+    _instance = None
+    _instance_lock = None
+    
+    def __new__(cls):
+        """Implement singleton pattern to prevent multiple instances."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        # Only initialize once
+        if self._initialized:
+            return
+        self._initialized = True
+        
+        # Socket.IO connection pool
+        self.connection_pool = SocketIOConnectionPool(max_connections=3)
+        
+        # Use bounded dictionaries to prevent unbounded memory growth
+        self.active_delegations = BoundedDict(MAX_DELEGATION_TRACKING)
+        self.delegation_requests = BoundedDict(MAX_DELEGATION_TRACKING)
+        self.pending_prompts = BoundedDict(MAX_PROMPT_TRACKING)
+        
+        # Limited delegation history
+        self.delegation_history = deque(maxlen=100)
+        
+        # Git branch cache with expiration
+        self._git_branch_cache = {}
+        self._git_branch_cache_time = {}
+        
+        # Track events processed for periodic cleanup
+        self.events_processed = 0
+        
+        # Initialize other components (simplified for brevity)
+        self.memory_hooks_initialized = False
+        self.pre_delegation_hook = None
+        self.post_delegation_hook = None
+        self.response_tracker = None
+        self.response_tracking_enabled = False
+        self.track_all_interactions = False
+        
+        if DEBUG:
+            print(f"✅ ClaudeHookHandler singleton initialized (pid: {os.getpid()})", file=sys.stderr)
+    
+    def _periodic_cleanup(self):
+        """Perform periodic cleanup of old data."""
+        self.events_processed += 1
+        
+        if self.events_processed % CLEANUP_INTERVAL_EVENTS == 0:
+            # Clean up old entries in bounded dictionaries
+            self.active_delegations.cleanup_old_entries(MAX_CACHE_AGE_SECONDS)
+            self.delegation_requests.cleanup_old_entries(MAX_CACHE_AGE_SECONDS)
+            self.pending_prompts.cleanup_old_entries(MAX_CACHE_AGE_SECONDS)
+            
+            # Clean up git branch cache
+            current_time = time.time()
+            expired_keys = [
+                key for key, cache_time in self._git_branch_cache_time.items()
+                if current_time - cache_time > MAX_CACHE_AGE_SECONDS
+            ]
+            for key in expired_keys:
+                self._git_branch_cache.pop(key, None)
+                self._git_branch_cache_time.pop(key, None)
+            
+            # Force garbage collection periodically
+            if self.events_processed % (CLEANUP_INTERVAL_EVENTS * 10) == 0:
+                gc.collect()
+                if DEBUG:
+                    print(f"🧹 Performed cleanup after {self.events_processed} events", file=sys.stderr)
+    
+    def _track_delegation(self, session_id: str, agent_type: str, request_data: dict = None):
+        """Track a new agent delegation with automatic cleanup."""
+        if session_id and agent_type and agent_type != 'unknown':
+            self.active_delegations[session_id] = agent_type
+            key = f"{session_id}:{datetime.now().timestamp()}"
+            self.delegation_history.append((key, agent_type))
+            
+            if request_data:
+                self.delegation_requests[session_id] = {
+                    'agent_type': agent_type,
+                    'request': request_data,
+                    'timestamp': datetime.now().isoformat()
+                }
+    
+    def _get_delegation_agent_type(self, session_id: str) -> str:
+        """Get the agent type for a session's active delegation."""
+        if session_id and session_id in self.active_delegations:
+            return self.active_delegations[session_id]
+        
+        # Check recent history
+        if session_id:
+            for key, agent_type in reversed(self.delegation_history):
+                if key.startswith(session_id):
+                    return agent_type
+        
+        return 'unknown'
+    
+    def _get_git_branch(self, working_dir: str = None) -> str:
+        """Get git branch with proper caching and expiration."""
+        if not working_dir:
+            working_dir = os.getcwd()
+        
+        cache_key = working_dir
+        current_time = time.time()
+        
+        # Check cache with expiration
+        if (cache_key in self._git_branch_cache and 
+            cache_key in self._git_branch_cache_time and
+            current_time - self._git_branch_cache_time[cache_key] < 30):
+            return self._git_branch_cache[cache_key]
+        
+        # Get git branch
+        try:
+            original_cwd = os.getcwd()
+            os.chdir(working_dir)
+            
+            result = subprocess.run(
+                ['git', 'branch', '--show-current'],
+                capture_output=True,
+                text=True,
+                timeout=TimeoutConfig.QUICK_TIMEOUT
+            )
+            
+            os.chdir(original_cwd)
+            
+            if result.returncode == 0 and result.stdout.strip():
+                branch = result.stdout.strip()
+                self._git_branch_cache[cache_key] = branch
+                self._git_branch_cache_time[cache_key] = current_time
+                return branch
+        except:
+            pass
+        
+        self._git_branch_cache[cache_key] = 'Unknown'
+        self._git_branch_cache_time[cache_key] = current_time
+        return 'Unknown'
+    
+    def _emit_socketio_event(self, namespace: str, event: str, data: dict):
+        """Emit Socket.IO event using connection pool."""
+        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+        client = self.connection_pool.get_connection(port)
+        
+        if not client:
+            return
+        
+        try:
+            claude_event_data = {
+                'type': f'hook.{event}',
+                'timestamp': datetime.now().isoformat(),
+                'data': data
+            }
+            client.emit('claude_event', claude_event_data)
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Socket.IO emit failed: {e}", file=sys.stderr)
+    
+    def handle(self):
+        """Process hook event with minimal overhead."""
+        try:
+            # Perform periodic cleanup
+            self._periodic_cleanup()
+            
+            # Read and parse event
+            event = self._read_hook_event()
+            if not event:
+                self._continue_execution()
+                return
+            
+            # Route event to appropriate handler
+            self._route_event(event)
+            
+            # Always continue execution
+            self._continue_execution()
+            
+        except:
+            # Fail fast and silent
+            self._continue_execution()
+    
+    def _read_hook_event(self) -> dict:
+        """Read and parse hook event from stdin."""
+        try:
+            event_data = sys.stdin.read()
+            return json.loads(event_data)
+        except:
+            return None
+    
+    def _route_event(self, event: dict) -> None:
+        """Route event to appropriate handler based on type."""
+        hook_type = event.get('hook_event_name', 'unknown')
+        
+        # Simplified routing (implement actual handlers as needed)
+        if DEBUG:
+            print(f"📥 Processing {hook_type} event", file=sys.stderr)
+    
+    def _continue_execution(self) -> None:
+        """Send continue action to Claude."""
+        print(json.dumps({"action": "continue"}))
+    
+    def __del__(self):
+        """Cleanup when handler is destroyed."""
+        if hasattr(self, 'connection_pool'):
+            self.connection_pool.close_all()
+
+
+# Global singleton instance
+_handler_instance = None
+
+
+def get_handler():
+    """Get the singleton handler instance."""
+    global _handler_instance
+    if _handler_instance is None:
+        _handler_instance = ClaudeHookHandler()
+    return _handler_instance
+
+
+def main():
+    """Entry point with proper singleton usage."""
+    try:
+        handler = get_handler()
+        handler.handle()
+    except Exception as e:
+        # Always output continue action to not block Claude
+        print(json.dumps({"action": "continue"}))
+        if DEBUG:
+            print(f"Hook handler error: {e}", file=sys.stderr)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

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

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

@@ -1,34 +1,35 @@
-claude_mpm/VERSION,sha256=XA-ecQ1vWbtZmARE89xYiG_FZKCi2KHVNNMpa-LGfag,6
+claude_mpm/VERSION,sha256=Lp-hVg19xAjkKCXIkTP803_6PSp9P5Eash7GshrXbNg,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
 claude_mpm/deployment_paths.py,sha256=JO7-fhhp_AkVB7ZssggHDBbee-r2sokpkqjoqnQLTmM,9073
 claude_mpm/init.py,sha256=hK_ROp6FsgTjpi-VJ_Z4FJICNEXwchh6F2KOqms-kfI,14938
 claude_mpm/ticket_wrapper.py,sha256=bWjLReYyuHSBguuiRm1d52rHYNHqrPJAOLUbMt4CnuM,836
-claude_mpm/agents/BASE_AGENT_TEMPLATE.md,sha256=VbIyiYPTpYB4FnhultZjjnlqfKKMcPywchTCVKWqE-s,6205
+claude_mpm/agents/BASE_AGENT_TEMPLATE.md,sha256=P1H5dBjwT3VsRVGxsCM1Wx7ViFhwCBWxNZOWLeJyRIw,2427
 claude_mpm/agents/BASE_PM.md,sha256=WxBF_Mif5a9hdXdr6m9K5X3KWQ6QKywk19pDV_SHNXI,5905
 claude_mpm/agents/INSTRUCTIONS.md,sha256=k5VfQUeUCJYxzav6MvtmC-D3XgIH3B_4HSgWuOfz_UQ,8305
-claude_mpm/agents/MEMORY.md,sha256=1Y-O_fSsbp7rSVhiC5QAHncPEr4RFvDk3Vvrd8bGedk,3207
-claude_mpm/agents/WORKFLOW.md,sha256=lQvJzacWNr24qML5MjfnY4xlvYPuRRF6A3nEXTolosc,2693
+claude_mpm/agents/MEMORY.md,sha256=zzwq4ytOrRaj64iq1q7brC6WOCQ4PDDC75TTRT8QudA,3493
+claude_mpm/agents/WORKFLOW.md,sha256=K1XqSlPNAs6HkcOSBTrOD7-0BcWCn90Sb6zX1EXtV6c,4686
 claude_mpm/agents/__init__.py,sha256=r-p7ervzjLPD7_8dm2tXX_fwvdTZy6KwKA03ofxN3sA,3275
 claude_mpm/agents/agent_loader.py,sha256=DgY0CMShaxdANV5GYT1Bd-lYizRKz89KpuR89VRx9GY,59534
 claude_mpm/agents/agent_loader_integration.py,sha256=h07Kmk4D75jmHxz5BucP6oQ5VhqVgQ35Sn5w3hcZNYI,7474
-claude_mpm/agents/agents_metadata.py,sha256=Xju9Yim6XSv2u1J_Swre5VJySbdxxC-9TzpOfXG8ibg,5170
+claude_mpm/agents/agents_metadata.py,sha256=C8GzqXB-AdWUzz2gpR-Dz3V2phUTbi1TRg1Xmxtdgxc,5853
 claude_mpm/agents/async_agent_loader.py,sha256=jHW3N13au-TlFSyo1_NhI8aExCt8QNumoWlrdtLp6V4,15145
 claude_mpm/agents/base_agent.json,sha256=Te1_Xi8zGoPKY_i4aYekyOqu-AVKqOcwVq-a41as9bA,5406
 claude_mpm/agents/base_agent_loader.py,sha256=Ur2pcYQXInS_z8MAD3154rvPn-zEpD2fx66iTSRDtY4,19015
 claude_mpm/agents/frontmatter_validator.py,sha256=OR6DWgGxV7b6A6WPAM9ikkDqCJitmp3UgYC45TkB5ZU,22630
 claude_mpm/agents/system_agent_config.py,sha256=Lke4FFjU0Vq3LLo4O7KvtHxadP7agAwC-ljCXK40h_A,23526
 claude_mpm/agents/backups/INSTRUCTIONS.md,sha256=tdekngpZ5RjECYZosOaDSBmXPZsVvZcwDQEmmlw7fOQ,14268
-claude_mpm/agents/schema/agent_schema.json,sha256=6fqrQUG3sPVX7IKdcP_LYYZeYt3W9NxNBzSG0-XOBCw,8747
+claude_mpm/agents/schema/agent_schema.json,sha256=l8qya45NCa-rMS5sdyiYOp-7D61dkoBRKrTgVy53-KE,8768
 claude_mpm/agents/templates/__init__.py,sha256=7UyIChghCnkrDctvmCRYr0Wrnn8Oj-eCdgL0KpFy1Mo,2668
 claude_mpm/agents/templates/code_analyzer.json,sha256=T6uM2pyzIhtL5vS7XKdNIrB_KxIatyOQv5dtT_7lmGM,17722
 claude_mpm/agents/templates/data_engineer.json,sha256=Dwwts56-z_Trh_gSIqGJBcjoNXBTDz0AuVdiA3T-kY4,15248
 claude_mpm/agents/templates/documentation.json,sha256=Cvk3mdmvWHA8SMEwS9zXtViMIUy2Q34JrYRLkV5nYdM,11905
 claude_mpm/agents/templates/engineer.json,sha256=C_90fbF54AZk8gwuxxLOTA5H8aXCt-7AwGWMN87JAxw,16570
 claude_mpm/agents/templates/ops.json,sha256=pXDc2RUQVv5qqDtZ9LGHXYFoccNkH5mBYIYHXSqp1h4,13776
+claude_mpm/agents/templates/project_organizer.json,sha256=d1VKgiT0t7GjUBp88kgqbW6A4txgHrFRYPNvrDYkJ80,17161
 claude_mpm/agents/templates/qa.json,sha256=ObztCsMr9haahOaHvaLDRHYj1TZwRxECuzluKscUb_M,10807
-claude_mpm/agents/templates/research.json,sha256=fQt8m1jS_qiowa239AiYkbJ2ab3bKZ2Pi8cG0eRCV2Y,15319
+claude_mpm/agents/templates/research.json,sha256=pk2Tg0GVSPEkPEnMw5Iax5QUFY8XY7uF1uPG6eHBe14,12336
 claude_mpm/agents/templates/security.json,sha256=KAJOIZeYUPbnC83S2q7ufwdmpS1xrEwWW6H9bvSNVdo,12349
 claude_mpm/agents/templates/ticketing.json,sha256=Kt9lyIXP5R_XTFrTH9ePkkPDnj9y4s-CQv7y4Hy2QVc,30054
 claude_mpm/agents/templates/version_control.json,sha256=yaRwaFA2JjMzCfGki2RIylKytjiVcn-lJKJ3jzTbuyY,11692
@@ -44,6 +45,7 @@ claude_mpm/agents/templates/backup/documentation_agent_20250726_234551.json,sha2
 claude_mpm/agents/templates/backup/engineer_agent_20250726_234551.json,sha256=21o8TGCM9TO6eocSV9Ev5MmCq-xYwwCqMU7KQESaY2Q,8479
 claude_mpm/agents/templates/backup/ops_agent_20250726_234551.json,sha256=y-unQijBWKAaPz3YCFoe21OMZXsU8jJ-mFrLGcmo8H0,2227
 claude_mpm/agents/templates/backup/qa_agent_20250726_234551.json,sha256=_FHWnUeh151rgWX_xUgXsfGrJz7Bs3wno2lXU0nTwAo,2157
+claude_mpm/agents/templates/backup/research_agent_2025011_234551.json,sha256=pk2Tg0GVSPEkPEnMw5Iax5QUFY8XY7uF1uPG6eHBe14,12336
 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
@@ -75,7 +77,7 @@ claude_mpm/core/agent_registry.py,sha256=YvEu-ZBc7XBi9KC2ZV8sWbVAuk0iwi38tg2cK45
 claude_mpm/core/agent_session_manager.py,sha256=6alXQr4gnMR-unT4J1ryEtTxJqQolA0-NgPQN6X3lqY,11212
 claude_mpm/core/base_service.py,sha256=qWI_rUybHmmKroptJxcE4rzPBhK8yeMKIt2JqnqJB7E,29125
 claude_mpm/core/cache.py,sha256=QoDzPSs6LFA4aKvoBe_PYdTLn0KbIYL4YlN-Z2iiPoc,18164
-claude_mpm/core/claude_runner.py,sha256=stIDHiyCRhl456QvqGGn03h1qZCyzsvoqM3BtOaLa6E,64885
+claude_mpm/core/claude_runner.py,sha256=rqUgQL31-oj8hzdcOcrn5HMhqB3X6SA13gA07QnT6bc,65743
 claude_mpm/core/config.py,sha256=G-vvQ9SjC8t6vlrvNodAFrHVEMm71GSarLzXt52p78k,28700
 claude_mpm/core/config_aliases.py,sha256=uilRxeIVMY4ZM_I7lnUeR0n4_nmiOpW2jY2_aW4udNA,10105
 claude_mpm/core/config_paths.py,sha256=SwoB02p7GVw5pnEasC5wPyjfFZKxCsQvQmepRCpm-Es,4971
@@ -134,6 +136,7 @@ claude_mpm/hooks/tool_call_interceptor.py,sha256=08_Odgm6Sg1zBJhGjwzVa03AReeBPZH
 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_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
 claude_mpm/models/agent_definition.py,sha256=y9XQOED_maOyiYKhNB8H8MfJJMBN0vIYPS_wCXnRJmA,6647
@@ -257,9 +260,9 @@ claude_mpm/utils/session_logging.py,sha256=9G0AzB7V0WkhLQlN0ocqbyDv0ifooEsJ5UPXI
 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.0.dist-info/licenses/LICENSE,sha256=cSdDfXjoTVhstrERrqme4zgxAu4GubU22zVEHsiXGxs,1071
-claude_mpm-3.9.0.dist-info/METADATA,sha256=6-Q3SdgmEsVt8Ccw58QMlQs3VQWq9EXWD4tG7zPtEcs,8680
-claude_mpm-3.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-3.9.0.dist-info/entry_points.txt,sha256=3_d7wLrg9sRmQ1SfrFGWoTNL8Wrd6lQb2XVSYbTwRIg,324
-claude_mpm-3.9.0.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-3.9.0.dist-info/RECORD,,
+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,,