claude-mpm 4.0.10__py3-none-any.whl → 4.0.11__py3-none-any.whl

claude_mpm/core/interactive_session.py

@@ -469,9 +469,9 @@ class InteractiveSession:
     def _show_available_agents(self) -> bool:
         """Show available agents in the system."""
         try:
-            from claude_mpm.cli import _get_agent_versions_display
+            from claude_mpm.cli.utils import get_agent_versions_display
 
-            agent_versions = _get_agent_versions_display()
+            agent_versions = get_agent_versions_display()
 
             if agent_versions:
                 print(agent_versions)

claude_mpm/dashboard/static/js/socket-client.js

@@ -20,14 +20,33 @@ class SocketClient {
         // Connection state
         this.isConnected = false;
         this.isConnecting = false;
+        this.lastConnectTime = null;
+        this.disconnectTime = null;
 
         // Event processing
         this.events = [];
         this.sessions = new Map();
         this.currentSessionId = null;
 
+        // Event queue for disconnection periods
+        this.eventQueue = [];
+        this.maxQueueSize = 100;
+        
+        // Retry configuration
+        this.retryAttempts = 0;
+        this.maxRetryAttempts = 3;
+        this.retryDelays = [1000, 2000, 4000]; // Exponential backoff
+        this.pendingEmissions = new Map(); // Track pending emissions for retry
+        
+        // Health monitoring
+        this.lastPingTime = null;
+        this.lastPongTime = null;
+        this.pingTimeout = 40000; // 40 seconds (server sends every 30s)
+        this.healthCheckInterval = null;
+        
         // Start periodic status check as fallback mechanism
         this.startStatusCheckFallback();
+        this.startHealthMonitoring();
     }
 
     /**
@@ -88,8 +107,21 @@ class SocketClient {
     setupSocketHandlers() {
         this.socket.on('connect', () => {
             console.log('Connected to Socket.IO server');
+            const previouslyConnected = this.isConnected;
             this.isConnected = true;
             this.isConnecting = false;
+            this.lastConnectTime = Date.now();
+            this.retryAttempts = 0; // Reset retry counter on successful connect
+            
+            // Calculate downtime if this is a reconnection
+            if (this.disconnectTime && previouslyConnected === false) {
+                const downtime = (Date.now() - this.disconnectTime) / 1000;
+                console.log(`Reconnected after ${downtime.toFixed(1)}s downtime`);
+                
+                // Flush queued events after reconnection
+                this.flushEventQueue();
+            }
+            
             this.notifyConnectionStatus('Connected', 'connected');
 
             // Emit connect callback
@@ -106,12 +138,25 @@ class SocketClient {
             console.log('Disconnected from server:', reason);
             this.isConnected = false;
             this.isConnecting = false;
+            this.disconnectTime = Date.now();
+            
+            // Calculate uptime
+            if (this.lastConnectTime) {
+                const uptime = (Date.now() - this.lastConnectTime) / 1000;
+                console.log(`Connection uptime was ${uptime.toFixed(1)}s`);
+            }
+            
             this.notifyConnectionStatus(`Disconnected: ${reason}`, 'disconnected');
 
             // Emit disconnect callback
             this.connectionCallbacks.disconnect.forEach(callback =>
                 callback(reason)
             );
+            
+            // Start auto-reconnect if it was an unexpected disconnect
+            if (reason === 'transport close' || reason === 'ping timeout') {
+                this.scheduleReconnect();
+            }
         });
 
         this.socket.on('connect_error', (error) => {
@@ -124,13 +169,20 @@ class SocketClient {
             this.addEvent({
                 type: 'connection.error',
                 timestamp: new Date().toISOString(),
-                data: { error: errorMsg, url: this.socket.io.uri }
+                data: { 
+                    error: errorMsg, 
+                    url: this.socket.io.uri,
+                    retry_attempt: this.retryAttempts
+                }
             });
 
             // Emit error callback
             this.connectionCallbacks.error.forEach(callback =>
                 callback(errorMsg)
             );
+            
+            // Schedule reconnect with backoff
+            this.scheduleReconnect();
         });
 
         // Primary event handler - this is what the server actually emits
@@ -143,6 +195,18 @@ class SocketClient {
             this.addEvent(transformedEvent);
         });
 
+        // Add ping/pong handlers for health monitoring
+        this.socket.on('ping', (data) => {
+            // console.log('Received ping from server');
+            this.lastPingTime = Date.now();
+            
+            // Send pong response immediately
+            this.socket.emit('pong', { 
+                timestamp: data.timestamp,
+                client_time: Date.now()
+            });
+        });
+        
         // Session and event handlers (legacy/fallback)
         this.socket.on('session.started', (data) => {
             this.addEvent({ type: 'session', subtype: 'started', timestamp: new Date().toISOString(), data });
@@ -235,13 +299,144 @@ class SocketClient {
         this.isConnecting = false;
     }
 
+    /**
+     * Emit an event with retry support
+     * @param {string} event - Event name
+     * @param {any} data - Event data
+     * @param {Object} options - Options for retry behavior
+     */
+    emitWithRetry(event, data = null, options = {}) {
+        const { 
+            maxRetries = 3,
+            retryDelays = [1000, 2000, 4000],
+            onSuccess = null,
+            onFailure = null
+        } = options;
+        
+        const emissionId = `${event}_${Date.now()}_${Math.random()}`;
+        
+        const attemptEmission = (attemptNum = 0) => {
+            if (!this.socket || !this.socket.connected) {
+                // Queue for later if disconnected
+                if (attemptNum === 0) {
+                    this.queueEvent(event, data);
+                    console.log(`Queued ${event} for later emission (disconnected)`);
+                    if (onFailure) onFailure('disconnected');
+                }
+                return;
+            }
+            
+            try {
+                // Attempt emission
+                this.socket.emit(event, data);
+                console.log(`Emitted ${event} successfully`);
+                
+                // Remove from pending
+                this.pendingEmissions.delete(emissionId);
+                
+                if (onSuccess) onSuccess();
+                
+            } catch (error) {
+                console.error(`Failed to emit ${event} (attempt ${attemptNum + 1}):`, error);
+                
+                if (attemptNum < maxRetries - 1) {
+                    const delay = retryDelays[attemptNum] || retryDelays[retryDelays.length - 1];
+                    console.log(`Retrying ${event} in ${delay}ms...`);
+                    
+                    // Store pending emission
+                    this.pendingEmissions.set(emissionId, {
+                        event,
+                        data,
+                        attemptNum: attemptNum + 1,
+                        scheduledTime: Date.now() + delay
+                    });
+                    
+                    setTimeout(() => attemptEmission(attemptNum + 1), delay);
+                } else {
+                    console.error(`Failed to emit ${event} after ${maxRetries} attempts`);
+                    this.pendingEmissions.delete(emissionId);
+                    if (onFailure) onFailure('max_retries_exceeded');
+                }
+            }
+        };
+        
+        attemptEmission();
+    }
+    
+    /**
+     * Queue an event for later emission
+     * @param {string} event - Event name
+     * @param {any} data - Event data
+     */
+    queueEvent(event, data) {
+        if (this.eventQueue.length >= this.maxQueueSize) {
+            // Remove oldest event if queue is full
+            const removed = this.eventQueue.shift();
+            console.warn(`Event queue full, dropped oldest event: ${removed.event}`);
+        }
+        
+        this.eventQueue.push({
+            event,
+            data,
+            timestamp: Date.now()
+        });
+    }
+    
+    /**
+     * Flush queued events after reconnection
+     */
+    flushEventQueue() {
+        if (this.eventQueue.length === 0) return;
+        
+        console.log(`Flushing ${this.eventQueue.length} queued events...`);
+        const events = [...this.eventQueue];
+        this.eventQueue = [];
+        
+        // Emit each queued event with a small delay between them
+        events.forEach((item, index) => {
+            setTimeout(() => {
+                if (this.socket && this.socket.connected) {
+                    this.socket.emit(item.event, item.data);
+                    console.log(`Flushed queued event: ${item.event}`);
+                }
+            }, index * 100); // 100ms between each event
+        });
+    }
+    
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     */
+    scheduleReconnect() {
+        if (this.retryAttempts >= this.maxRetryAttempts) {
+            console.log('Max reconnection attempts reached, stopping auto-reconnect');
+            this.notifyConnectionStatus('Reconnection failed', 'disconnected');
+            return;
+        }
+        
+        const delay = this.retryDelays[this.retryAttempts] || this.retryDelays[this.retryDelays.length - 1];
+        this.retryAttempts++;
+        
+        console.log(`Scheduling reconnect attempt ${this.retryAttempts}/${this.maxRetryAttempts} in ${delay}ms...`);
+        this.notifyConnectionStatus(`Reconnecting in ${delay/1000}s...`, 'connecting');
+        
+        setTimeout(() => {
+            if (!this.isConnected && this.port) {
+                console.log(`Attempting reconnection ${this.retryAttempts}/${this.maxRetryAttempts}...`);
+                this.connect(this.port);
+            }
+        }, delay);
+    }
+    
     /**
      * Request server status
      */
     requestStatus() {
         if (this.socket && this.socket.connected) {
             console.log('Requesting server status...');
-            this.socket.emit('request.status');
+            this.emitWithRetry('request.status', null, {
+                maxRetries: 2,
+                retryDelays: [500, 1000]
+            });
         }
     }
 
@@ -258,7 +453,13 @@ class SocketClient {
                 event_types: options.event_types || []
             };
             console.log('Requesting event history...', params);
-            this.socket.emit('get_history', params);
+            this.emitWithRetry('get_history', params, {
+                maxRetries: 3,
+                retryDelays: [1000, 2000, 3000],
+                onFailure: (reason) => {
+                    console.error(`Failed to request history: ${reason}`);
+                }
+            });
         } else {
             console.warn('Cannot request history: not connected to server');
         }
@@ -554,6 +755,43 @@ class SocketClient {
         };
     }
 
+    /**
+     * Start health monitoring
+     * Detects stale connections and triggers reconnection
+     */
+    startHealthMonitoring() {
+        this.healthCheckInterval = setInterval(() => {
+            if (this.isConnected && this.lastPingTime) {
+                const timeSinceLastPing = Date.now() - this.lastPingTime;
+                
+                if (timeSinceLastPing > this.pingTimeout) {
+                    console.warn(`No ping from server for ${timeSinceLastPing/1000}s, connection may be stale`);
+                    
+                    // Force reconnection
+                    if (this.socket) {
+                        console.log('Forcing reconnection due to stale connection...');
+                        this.socket.disconnect();
+                        setTimeout(() => {
+                            if (this.port) {
+                                this.connect(this.port);
+                            }
+                        }, 1000);
+                    }
+                }
+            }
+        }, 10000); // Check every 10 seconds
+    }
+    
+    /**
+     * Stop health monitoring
+     */
+    stopHealthMonitoring() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+    
     /**
      * Start periodic status check as fallback mechanism
      * This ensures the UI stays in sync with actual socket state
@@ -615,6 +853,35 @@ class SocketClient {
     }
 }
 
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        this.stopHealthMonitoring();
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        this.eventQueue = [];
+        this.pendingEmissions.clear();
+    }
+    
+    /**
+     * Get connection metrics
+     * @returns {Object} Connection metrics
+     */
+    getConnectionMetrics() {
+        return {
+            isConnected: this.isConnected,
+            uptime: this.lastConnectTime ? (Date.now() - this.lastConnectTime) / 1000 : 0,
+            lastPing: this.lastPingTime ? (Date.now() - this.lastPingTime) / 1000 : null,
+            queuedEvents: this.eventQueue.length,
+            pendingEmissions: this.pendingEmissions.size,
+            retryAttempts: this.retryAttempts
+        };
+    }
+}
+
 // ES6 Module export
 export { SocketClient };
 export default SocketClient;

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -903,7 +903,9 @@ def main():
             )
         # Always output continue action to not block Claude
         print(json.dumps({"action": "continue"}))
-        sys.exit(0)
+        # Only exit if this is a signal handler call, not atexit
+        if signum is not None:
+            sys.exit(0)
 
     # Register cleanup handlers
     signal.signal(signal.SIGTERM, cleanup_handler)

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -45,12 +45,12 @@ export CLAUDE_MPM_HOOK_DEBUG="true"
 
 # Debug log (optional)
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHONPATH: $PYTHONPATH" >> /tmp/hook-wrapper.log
-echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD $SCRIPT_DIR/hook_handler.py" >> /tmp/hook-wrapper.log
+echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD -m claude_mpm.hooks.claude_hooks.hook_handler" >> /tmp/hook-wrapper.log
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] SOCKETIO_PORT: $CLAUDE_MPM_SOCKETIO_PORT" >> /tmp/hook-wrapper.log
 
-# Run the Python hook handler with error handling
+# Run the Python hook handler as a module with error handling
 # Use exec to replace the shell process, but wrap in error handling
-if ! "$PYTHON_CMD" "$SCRIPT_DIR/hook_handler.py" "$@" 2>/tmp/hook-error.log; then
+if ! "$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/hook-error.log; then
     # If the Python handler fails, always return continue to not block Claude
     echo '{"action": "continue"}'
     # Log the error for debugging

claude_mpm/services/agents/memory/agent_memory_manager.py

@@ -82,7 +82,7 @@ class AgentMemoryManager(MemoryServiceInterface):
         self._logger_name = None
 
         self.config = config or Config()
-        self.project_root = get_path_manager().get_project_root()
+        self.project_root = get_path_manager().project_root
         # Use current working directory by default, not project root
         self.working_directory = working_directory or Path(os.getcwd())
         self.memories_dir = self.working_directory / ".claude-mpm" / "memories"

claude_mpm/services/socketio/handlers/connection.py

@@ -5,13 +5,87 @@ disconnect, status requests, and history management. Separating these
 from other handlers makes connection management more maintainable.
 """
 
+import asyncio
+import functools
+import time
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Callable, Dict, List, Optional, Set
 
 from ....core.typing_utils import ClaudeStatus, EventData, SocketId
 from .base import BaseEventHandler
 
 
+def timeout_handler(timeout_seconds: float = 5.0):
+    """Decorator to add timeout protection to async handlers.
+    
+    WHY: Network operations can hang indefinitely, causing resource leaks
+    and poor user experience. This decorator ensures handlers complete
+    within a reasonable time or fail gracefully.
+    
+    Args:
+        timeout_seconds: Maximum time allowed for handler execution (default: 5s)
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            handler_name = func.__name__
+            start_time = time.time()
+            
+            try:
+                # Create a task with timeout
+                result = await asyncio.wait_for(
+                    func(self, *args, **kwargs),
+                    timeout=timeout_seconds
+                )
+                
+                elapsed = time.time() - start_time
+                if elapsed > timeout_seconds * 0.8:  # Warn if close to timeout
+                    self.logger.warning(
+                        f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
+                        f"(close to {timeout_seconds}s timeout)"
+                    )
+                    
+                return result
+                
+            except asyncio.TimeoutError:
+                elapsed = time.time() - start_time
+                self.logger.error(
+                    f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
+                )
+                
+                # Try to send error response to client if we have their sid
+                if args and isinstance(args[0], str):  # First arg is usually sid
+                    sid = args[0]
+                    try:
+                        # Use a short timeout for error response
+                        await asyncio.wait_for(
+                            self.emit_to_client(
+                                sid, 
+                                "error",
+                                {
+                                    "message": f"Handler {handler_name} timed out",
+                                    "handler": handler_name,
+                                    "timeout": timeout_seconds
+                                }
+                            ),
+                            timeout=1.0
+                        )
+                    except:
+                        pass  # Best effort error notification
+                        
+                return None
+                
+            except Exception as e:
+                elapsed = time.time() - start_time
+                self.logger.error(
+                    f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
+                )
+                raise
+                
+        return wrapper
+    return decorator
+
+
 class ConnectionEventHandler(BaseEventHandler):
     """Handles Socket.IO connection lifecycle events.
 
@@ -19,11 +93,189 @@ class ConnectionEventHandler(BaseEventHandler):
     that deserves its own focused handler. This includes client connections,
     disconnections, status updates, and event history management.
     """
+    
+    def __init__(self, server):
+        """Initialize connection handler with health monitoring.
+        
+        WHY: We need to track connection health metrics and implement
+        ping/pong mechanism for detecting stale connections.
+        """
+        super().__init__(server)
+        
+        # Connection health tracking
+        self.connection_metrics = {}
+        self.last_ping_times = {}
+        self.ping_interval = 30  # seconds
+        self.ping_timeout = 10  # seconds
+        self.stale_check_interval = 60  # seconds
+        
+        # Health monitoring tasks (will be started after event registration)
+        self.ping_task = None
+        self.stale_check_task = None
 
+    def _start_health_monitoring(self):
+        """Start background tasks for connection health monitoring.
+        
+        WHY: We need to actively monitor connection health to detect
+        and clean up stale connections, ensuring reliable event delivery.
+        """
+        # Only start if we have a valid event loop and tasks aren't already running
+        if hasattr(self.server, 'core') and hasattr(self.server.core, 'loop'):
+            loop = self.server.core.loop
+            if loop and not loop.is_closed():
+                if not self.ping_task or self.ping_task.done():
+                    self.ping_task = asyncio.run_coroutine_threadsafe(
+                        self._periodic_ping(), loop
+                    )
+                    self.logger.info("🏓 Started connection ping monitoring")
+                
+                if not self.stale_check_task or self.stale_check_task.done():
+                    self.stale_check_task = asyncio.run_coroutine_threadsafe(
+                        self._check_stale_connections(), loop
+                    )
+                    self.logger.info("🧹 Started stale connection checker")
+    
+    def stop_health_monitoring(self):
+        """Stop health monitoring tasks.
+        
+        WHY: Clean shutdown requires stopping background tasks to
+        prevent errors and resource leaks.
+        """
+        if self.ping_task and not self.ping_task.done():
+            self.ping_task.cancel()
+            self.logger.info("🚫 Stopped connection ping monitoring")
+        
+        if self.stale_check_task and not self.stale_check_task.done():
+            self.stale_check_task.cancel()
+            self.logger.info("🚫 Stopped stale connection checker")
+    
+    async def _periodic_ping(self):
+        """Send periodic pings to all connected clients.
+        
+        WHY: WebSocket connections can silently fail. Regular pings
+        help detect dead connections and maintain connection state.
+        """
+        while True:
+            try:
+                await asyncio.sleep(self.ping_interval)
+                
+                if not self.clients:
+                    continue
+                    
+                current_time = time.time()
+                disconnected = []
+                
+                for sid in list(self.clients):
+                    try:
+                        # Send ping and record time
+                        await self.sio.emit('ping', {'timestamp': current_time}, room=sid)
+                        self.last_ping_times[sid] = current_time
+                        
+                        # Update connection metrics
+                        if sid not in self.connection_metrics:
+                            self.connection_metrics[sid] = {
+                                'connected_at': current_time,
+                                'reconnects': 0,
+                                'failures': 0,
+                                'last_activity': current_time
+                            }
+                        self.connection_metrics[sid]['last_activity'] = current_time
+                        
+                    except Exception as e:
+                        self.logger.warning(f"Failed to ping client {sid}: {e}")
+                        disconnected.append(sid)
+                
+                # Clean up failed connections
+                for sid in disconnected:
+                    await self._cleanup_stale_connection(sid)
+                    
+                if self.clients:
+                    self.logger.debug(
+                        f"🏓 Sent pings to {len(self.clients)} clients, "
+                        f"{len(disconnected)} failed"
+                    )
+                    
+            except Exception as e:
+                self.logger.error(f"Error in periodic ping: {e}")
+    
+    async def _check_stale_connections(self):
+        """Check for and clean up stale connections.
+        
+        WHY: Some clients may not properly disconnect, leaving zombie
+        connections that consume resources and prevent proper cleanup.
+        """
+        while True:
+            try:
+                await asyncio.sleep(self.stale_check_interval)
+                
+                current_time = time.time()
+                stale_threshold = current_time - (self.ping_timeout + self.ping_interval)
+                stale_sids = []
+                
+                for sid in list(self.clients):
+                    last_ping = self.last_ping_times.get(sid, 0)
+                    
+                    if last_ping < stale_threshold:
+                        stale_sids.append(sid)
+                        self.logger.warning(
+                            f"🧟 Detected stale connection {sid} "
+                            f"(last ping: {current_time - last_ping:.1f}s ago)"
+                        )
+                
+                # Clean up stale connections
+                for sid in stale_sids:
+                    await self._cleanup_stale_connection(sid)
+                    
+                if stale_sids:
+                    self.logger.info(
+                        f"🧹 Cleaned up {len(stale_sids)} stale connections"
+                    )
+                    
+            except Exception as e:
+                self.logger.error(f"Error checking stale connections: {e}")
+    
+    async def _cleanup_stale_connection(self, sid: str):
+        """Clean up a stale or dead connection.
+        
+        WHY: Proper cleanup prevents memory leaks and ensures
+        accurate connection tracking.
+        """
+        try:
+            if sid in self.clients:
+                self.clients.remove(sid)
+                
+            if sid in self.last_ping_times:
+                del self.last_ping_times[sid]
+                
+            if sid in self.connection_metrics:
+                metrics = self.connection_metrics[sid]
+                uptime = time.time() - metrics.get('connected_at', 0)
+                self.logger.info(
+                    f"📊 Connection {sid} stats - uptime: {uptime:.1f}s, "
+                    f"reconnects: {metrics.get('reconnects', 0)}, "
+                    f"failures: {metrics.get('failures', 0)}"
+                )
+                del self.connection_metrics[sid]
+                
+            # Force disconnect if still connected
+            try:
+                await self.sio.disconnect(sid)
+            except:
+                pass  # Already disconnected
+                
+            self.logger.info(f"🔌 Cleaned up stale connection: {sid}")
+            
+        except Exception as e:
+            self.logger.error(f"Error cleaning up connection {sid}: {e}")
+    
     def register_events(self) -> None:
         """Register connection-related event handlers."""
+        
+        # Start health monitoring now that we're registering events
+        self._start_health_monitoring()
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=5.0)
         async def connect(sid, environ, *args):
             """Handle client connection.
 
@@ -72,6 +324,7 @@ class ConnectionEventHandler(BaseEventHandler):
                 self.log_error(f"sending welcome to client {sid}", e)
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=3.0)
         async def disconnect(sid):
             """Handle client disconnection.
 
@@ -86,8 +339,15 @@ class ConnectionEventHandler(BaseEventHandler):
                 self.logger.warning(
                     f"⚠️  Attempted to disconnect unknown client: {sid}"
                 )
+            
+            # Clean up health tracking
+            if sid in self.last_ping_times:
+                del self.last_ping_times[sid]
+            if sid in self.connection_metrics:
+                del self.connection_metrics[sid]
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=3.0)
         async def get_status(sid):
             """Handle status request.
 
@@ -105,6 +365,7 @@ class ConnectionEventHandler(BaseEventHandler):
             await self.emit_to_client(sid, "status", status_data)
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=5.0)
         async def get_history(sid, data=None):
             """Handle history request.
 
@@ -118,6 +379,7 @@ class ConnectionEventHandler(BaseEventHandler):
             await self._send_event_history(sid, event_types=event_types, limit=limit)
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=5.0)
         async def request_history(sid, data=None):
             """Handle legacy history request (for client compatibility).
 
@@ -131,6 +393,7 @@ class ConnectionEventHandler(BaseEventHandler):
             await self._send_event_history(sid, event_types=event_types, limit=limit)
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=3.0)
         async def subscribe(sid, data=None):
             """Handle subscription request.
 
@@ -141,6 +404,7 @@ class ConnectionEventHandler(BaseEventHandler):
             await self.emit_to_client(sid, "subscribed", {"channels": channels})
 
         @self.sio.event
+        @timeout_handler(timeout_seconds=5.0)
         async def claude_event(sid, data):
             """Handle events from client proxies.
 
@@ -198,6 +462,25 @@ class ConnectionEventHandler(BaseEventHandler):
             self.logger.info(f"📡 Broadcasting claude_event to all clients except {sid}")
             await self.broadcast_event("claude_event", data, skip_sid=sid)
             self.logger.info(f"✅ Broadcast complete")
+        
+        @self.sio.event
+        async def pong(sid, data=None):
+            """Handle pong response from client.
+            
+            WHY: Clients respond to our pings with pongs, confirming
+            they're still alive and the connection is healthy.
+            """
+            current_time = time.time()
+            
+            # Update last activity time
+            if sid in self.connection_metrics:
+                self.connection_metrics[sid]['last_activity'] = current_time
+                
+            # Calculate round-trip time if timestamp provided
+            if data and 'timestamp' in data:
+                rtt = current_time - data['timestamp']
+                if rtt < 10:  # Reasonable RTT
+                    self.logger.debug(f"🏓 Pong from {sid}, RTT: {rtt*1000:.1f}ms")
 
     def _normalize_event(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
         """Normalize event format to ensure consistency.

claude_mpm/services/socketio/server/broadcaster.py

@@ -10,12 +10,144 @@ to create focused, testable modules with single responsibilities.
 """
 
 import asyncio
+import time
+from collections import deque
+from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Deque, Dict, List, Optional, Set
 
 from ....core.logging_config import get_logger
 
 
+@dataclass
+class RetryableEvent:
+    """Represents an event that can be retried on failure.
+    
+    WHY: Network failures are common and transient. By tracking retry
+    attempts, we can recover from temporary issues while avoiding
+    infinite retry loops.
+    """
+    event_type: str
+    data: Dict[str, Any]
+    attempt_count: int = 0
+    max_retries: int = 3
+    created_at: float = None
+    last_attempt: float = None
+    skip_sid: Optional[str] = None
+    
+    def __post_init__(self):
+        if self.created_at is None:
+            self.created_at = time.time()
+        if self.last_attempt is None:
+            self.last_attempt = time.time()
+    
+    def should_retry(self) -> bool:
+        """Check if this event should be retried.
+        
+        WHY: We need to balance reliability with resource usage.
+        Events older than 30 seconds or with too many attempts
+        should be abandoned.
+        """
+        if self.attempt_count >= self.max_retries:
+            return False
+        
+        # Don't retry events older than 30 seconds
+        if time.time() - self.created_at > 30:
+            return False
+            
+        return True
+    
+    def get_backoff_delay(self) -> float:
+        """Calculate exponential backoff delay.
+        
+        WHY: Exponential backoff prevents overwhelming the system
+        during recovery from failures.
+        """
+        base_delay = 1.0  # 1 second
+        max_delay = 8.0   # 8 seconds max
+        
+        delay = min(base_delay * (2 ** self.attempt_count), max_delay)
+        return delay
+
+
+class RetryQueue:
+    """Manages retry queue for failed event broadcasts.
+    
+    WHY: Transient network issues shouldn't cause event loss.
+    This queue provides resilient event delivery with backoff.
+    """
+    
+    def __init__(self, max_size: int = 1000):
+        self.queue: Deque[RetryableEvent] = deque(maxlen=max_size)
+        self.lock = asyncio.Lock()
+        self.stats = {
+            'queued': 0,
+            'retried': 0,
+            'succeeded': 0,
+            'abandoned': 0
+        }
+    
+    async def add(self, event: RetryableEvent) -> None:
+        """Add an event to the retry queue."""
+        async with self.lock:
+            self.queue.append(event)
+            self.stats['queued'] += 1
+    
+    async def get_ready_events(self) -> List[RetryableEvent]:
+        """Get events that are ready for retry.
+        
+        WHY: We need to respect backoff delays to avoid
+        overwhelming the system during recovery.
+        """
+        async with self.lock:
+            current_time = time.time()
+            ready = []
+            
+            # Check each event in queue
+            remaining = []
+            for event in self.queue:
+                if not event.should_retry():
+                    self.stats['abandoned'] += 1
+                    continue
+                
+                # First attempt (attempt_count == 0) should be immediate
+                if event.attempt_count == 0:
+                    ready.append(event)
+                else:
+                    # For retries, check backoff delay
+                    time_since_attempt = current_time - event.last_attempt
+                    if time_since_attempt >= event.get_backoff_delay():
+                        ready.append(event)
+                    else:
+                        remaining.append(event)
+            
+            # Update queue with events not ready yet
+            self.queue.clear()
+            self.queue.extend(remaining)
+            
+            return ready
+    
+    async def mark_success(self, event: RetryableEvent) -> None:
+        """Mark an event as successfully sent."""
+        self.stats['succeeded'] += 1
+    
+    async def mark_retry(self, event: RetryableEvent) -> None:
+        """Mark an event for retry."""
+        event.attempt_count += 1
+        event.last_attempt = time.time()
+        self.stats['retried'] += 1
+        
+        if event.should_retry():
+            await self.add(event)
+    
+    def get_stats(self) -> Dict[str, int]:
+        """Get retry queue statistics."""
+        return {
+            **self.stats,
+            'queue_size': len(self.queue)
+        }
+
+
 class SocketIOEventBroadcaster:
     """Handles broadcasting events to connected Socket.IO clients.
 
@@ -41,9 +173,113 @@ class SocketIOEventBroadcaster:
         self.logger = logger
         self.loop = None  # Will be set by main server
         self.server = server  # Reference to main server for event history
-
-    def broadcast_event(self, event_type: str, data: Dict[str, Any]):
-        """Broadcast an event to all connected clients."""
+        
+        # Initialize retry queue for resilient delivery
+        self.retry_queue = RetryQueue(max_size=1000)
+        self.retry_task = None
+        self.retry_interval = 2.0  # Process retry queue every 2 seconds
+    
+    def start_retry_processor(self):
+        """Start the background retry processor.
+        
+        WHY: Failed broadcasts need to be retried automatically
+        to ensure reliable event delivery.
+        """
+        if self.loop and not self.retry_task:
+            self.retry_task = asyncio.create_task(self._process_retry_queue())
+            self.logger.info("🔄 Started retry queue processor")
+    
+    def stop_retry_processor(self):
+        """Stop the background retry processor."""
+        if self.retry_task:
+            self.retry_task.cancel()
+            self.retry_task = None
+            self.logger.info("🚫 Stopped retry queue processor")
+    
+    async def _process_retry_queue(self):
+        """Process the retry queue periodically.
+        
+        WHY: Regular processing ensures failed events are retried
+        with appropriate backoff delays.
+        """
+        while True:
+            try:
+                await asyncio.sleep(self.retry_interval)
+                
+                # Get events ready for retry
+                ready_events = await self.retry_queue.get_ready_events()
+                
+                if ready_events:
+                    self.logger.debug(
+                        f"🔄 Processing {len(ready_events)} events from retry queue"
+                    )
+                    
+                    for event in ready_events:
+                        success = await self._retry_broadcast(event)
+                        
+                        if success:
+                            await self.retry_queue.mark_success(event)
+                        else:
+                            await self.retry_queue.mark_retry(event)
+                    
+                    # Log stats periodically
+                    stats = self.retry_queue.get_stats()
+                    if stats['retried'] > 0 or stats['abandoned'] > 0:
+                        self.logger.info(
+                            f"📊 Retry queue stats - "
+                            f"queued: {stats['queued']}, "
+                            f"retried: {stats['retried']}, "
+                            f"succeeded: {stats['succeeded']}, "
+                            f"abandoned: {stats['abandoned']}, "
+                            f"current size: {stats['queue_size']}"
+                        )
+                        
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Error processing retry queue: {e}")
+    
+    async def _retry_broadcast(self, event: RetryableEvent) -> bool:
+        """Retry broadcasting a failed event.
+        
+        WHY: Isolated retry logic allows for special handling
+        and metrics tracking of retry attempts.
+        """
+        try:
+            self.logger.debug(
+                f"🔄 Retrying {event.event_type} (attempt {event.attempt_count + 1}/{event.max_retries})"
+            )
+            
+            # Reconstruct the full event
+            full_event = {
+                "type": event.event_type,
+                "timestamp": datetime.now().isoformat(),
+                "data": event.data,
+                "retry_attempt": event.attempt_count + 1
+            }
+            
+            # Attempt broadcast
+            if event.skip_sid:
+                await self.sio.emit("claude_event", full_event, skip_sid=event.skip_sid)
+            else:
+                await self.sio.emit("claude_event", full_event)
+            
+            self.logger.debug(f"✅ Successfully retried {event.event_type}")
+            return True
+            
+        except Exception as e:
+            self.logger.warning(
+                f"⚠️ Retry failed for {event.event_type} "
+                f"(attempt {event.attempt_count + 1}): {e}"
+            )
+            return False
+
+    def broadcast_event(self, event_type: str, data: Dict[str, Any], skip_sid: Optional[str] = None):
+        """Broadcast an event to all connected clients with retry support.
+        
+        WHY: Enhanced with retry queue to ensure reliable delivery
+        even during transient network issues.
+        """
         if not self.sio:
             return
 
@@ -65,15 +301,27 @@ class SocketIOEventBroadcaster:
                 self.logger.debug(f"Added {event_type} to history (total: {len(self.server.event_history)})")
 
         # Broadcast to all connected clients
+        broadcast_success = False
         try:
             # Use run_coroutine_threadsafe to safely call from any thread
             if hasattr(self, "loop") and self.loop and not self.loop.is_closed():
-                future = asyncio.run_coroutine_threadsafe(
-                    self.sio.emit("claude_event", event), self.loop
-                )
-                # Don't wait for the result to avoid blocking
-                self.stats["events_sent"] += 1
-                self.logger.debug(f"Broadcasted event: {event_type}")
+                # Create broadcast coroutine
+                if skip_sid:
+                    coro = self.sio.emit("claude_event", event, skip_sid=skip_sid)
+                else:
+                    coro = self.sio.emit("claude_event", event)
+                
+                future = asyncio.run_coroutine_threadsafe(coro, self.loop)
+                
+                # Wait briefly to see if broadcast succeeds
+                try:
+                    future.result(timeout=0.5)  # 500ms timeout
+                    broadcast_success = True
+                    self.stats["events_sent"] += 1
+                    self.logger.debug(f"Broadcasted event: {event_type}")
+                except:
+                    # Will be added to retry queue below
+                    pass
             else:
                 self.logger.warning(
                     f"Cannot broadcast {event_type}: server loop not available"
@@ -81,6 +329,24 @@ class SocketIOEventBroadcaster:
 
         except Exception as e:
             self.logger.error(f"Failed to broadcast event {event_type}: {e}")
+        
+        # Add to retry queue if broadcast failed
+        if not broadcast_success and self.loop:
+            retryable_event = RetryableEvent(
+                event_type=event_type,
+                data=data,
+                skip_sid=skip_sid
+            )
+            
+            # Queue for retry
+            asyncio.run_coroutine_threadsafe(
+                self.retry_queue.add(retryable_event),
+                self.loop
+            )
+            
+            self.logger.warning(
+                f"⚠️ Queued {event_type} for retry (queue size: {len(self.retry_queue.queue)})"
+            )
 
     def session_started(self, session_id: str, launch_method: str, working_dir: str):
         """Notify that a session has started."""

claude_mpm/services/socketio/server/main.py

@@ -119,6 +119,9 @@ class SocketIOServer(SocketIOServiceInterface):
 
         # Set the loop reference for broadcaster
         self.broadcaster.loop = self.core.loop
+        
+        # Start the retry processor for resilient event delivery
+        self.broadcaster.start_retry_processor()
 
         # Register events
         self._register_events()
@@ -128,11 +131,22 @@ class SocketIOServer(SocketIOServiceInterface):
         self.stats["start_time"] = self.core.stats["start_time"]
 
         self.logger.info(
-            f"SocketIO server started successfully on {self.host}:{self.port}"
+            f"SocketIO server started successfully on {self.host}:{self.port} with retry queue enabled"
         )
 
     def stop_sync(self):
         """Stop the Socket.IO server (synchronous version)."""
+        # Stop the retry processor if running
+        if self.broadcaster:
+            self.broadcaster.stop_retry_processor()
+        
+        # Stop health monitoring in connection handler
+        if self.event_registry:
+            from ..handlers import ConnectionEventHandler
+            conn_handler = self.event_registry.get_handler(ConnectionEventHandler)
+            if conn_handler and hasattr(conn_handler, 'stop_health_monitoring'):
+                conn_handler.stop_health_monitoring()
+        
         self.core.stop_sync()
         self.running = False
 

{claude_mpm-4.0.10.dist-info → claude_mpm-4.0.11.dist-info}/METADATA

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

@@ -106,7 +106,7 @@ claude_mpm/core/framework_loader.py,sha256=E_l5hrqwrGvAWCE-CHwjqAQErjxdzwgJ7AY31
 claude_mpm/core/hook_manager.py,sha256=N-54QwNsyrUZSrH533HAo6hlJKPFbgMeDirg92H8en8,11014
 claude_mpm/core/hook_performance_config.py,sha256=Cqf-89mjiLlFJ-v4PhxfzsaOVovYYQa5pa-RMm42Ki8,5748
 claude_mpm/core/injectable_service.py,sha256=HXuviYX-h0sNxOFzgZiYjf-gLDUnQIeG-0-KuWdfCzk,7397
-claude_mpm/core/interactive_session.py,sha256=sYe2Fob6HxyTYWdvWn0rpCDYlwSmpB1_PUgjb2DXLC4,18998
+claude_mpm/core/interactive_session.py,sha256=bYrQDEYUvKAoQEEU8CVBlqE2nkDhLqJQCijbGJQnHxw,19002
 claude_mpm/core/interfaces.py,sha256=unClq54EgOIamVICS0G_LJzUa4gLXixqfDxiAvNjEkk,26914
 claude_mpm/core/lazy.py,sha256=to0DBciTUnWL9UO8o5bCVSgFCRHE1VtSrgX_B8qYg0Y,14724
 claude_mpm/core/logger.py,sha256=lzwREb0SBEXL-IkCRnJHK_GKuRaegNOx4CJltfAsNAE,15774
@@ -162,7 +162,7 @@ claude_mpm/dashboard/static/dist/components/ui-state-manager.js,sha256=PtZs6sxNh
 claude_mpm/dashboard/static/dist/components/working-directory.js,sha256=7V1pBeuxWOxZVlDp3kZvivTHAfzucv2ceBXWP6SlZTY,15339
 claude_mpm/dashboard/static/js/dashboard.js,sha256=4u-oV6k_AUj8PneNXbCoDnYiGG2y6e6eHr5JIisfTXg,60178
 claude_mpm/dashboard/static/js/extension-error-handler.js,sha256=DZHrJ3gbfv4nsjmZpNMj-Sc3GKjVJ5ds8lgoaLRnq5I,6274
-claude_mpm/dashboard/static/js/socket-client.js,sha256=PGqEgj_obpKHwPNMQB8K1glQUOL3RIfjADRxpLPCpwQ,22738
+claude_mpm/dashboard/static/js/socket-client.js,sha256=miNfAKfJr5z4br5eOpZMVoKLS5LBYO0Rp2q6I0xroW4,32437
 claude_mpm/dashboard/static/js/components/agent-inference.js,sha256=BDqgr1o0DlcgzNa5KwDsNODelQvXA-tab0O1PeAnVtM,27269
 claude_mpm/dashboard/static/js/components/event-processor.js,sha256=_GnAz8pxN1iyXw0O4AIR482QFyQAigEKO9IDUOUbGqc,24844
 claude_mpm/dashboard/static/js/components/event-viewer.js,sha256=aHF__HZHZsfSkpELb4GAIGxNrFGAiBcizrWW00bTG9c,33105
@@ -188,8 +188,8 @@ claude_mpm/hooks/validation_hooks.py,sha256=w3bSApxZE6hfLnBLVEs62DpJ6grxOr1-JZn1
 claude_mpm/hooks/claude_hooks/__init__.py,sha256=b4mud_g3S-3itHY_Dzpbb_SmdMEcJwtUU8fTcqpLqqs,130
 claude_mpm/hooks/claude_hooks/connection_pool.py,sha256=8bluFsgiM6HUJuNw-Dl7RkuzLR1vVMWGdEwucp9r3gc,6508
 claude_mpm/hooks/claude_hooks/event_handlers.py,sha256=rLaKV_pV8NOCwbJQtg7At0xYNfYcCDiajSge7TiiuPk,30081
-claude_mpm/hooks/claude_hooks/hook_handler.py,sha256=Q4IDqEh9hsFNxsGuEkmCVhRuA2OKhBQ5X5vuLF_Ryuc,38549
-claude_mpm/hooks/claude_hooks/hook_wrapper.sh,sha256=R0Gt-5Rt5_889PH57d8iXfOp38N5sv7SaF_QolYbTXw,2359
+claude_mpm/hooks/claude_hooks/hook_handler.py,sha256=quEOyJ6pKwxPdzoFt9RaFHa9u88nNdLN7mvg6_a-5F0,38649
+claude_mpm/hooks/claude_hooks/hook_wrapper.sh,sha256=xcNT3yIx9srBSd_9aosBp9w45JwaZHDlsp5ocio9cM8,2405
 claude_mpm/hooks/claude_hooks/memory_integration.py,sha256=fxkawPwMkMCGxJ5Ki_PJ7blN1vtQXEYqGxxQPJytOq4,8801
 claude_mpm/hooks/claude_hooks/response_tracking.py,sha256=Cm5uyWgMLC5HZF0FA0xhP7bhQ1vC1H3Cak8wfzzW5MU,13887
 claude_mpm/hooks/claude_hooks/tool_analysis.py,sha256=z75UOImtbECItB0pleRUSeNXqjh0jk3dMWq6eekPQw8,7981
@@ -292,7 +292,7 @@ claude_mpm/services/agents/management/__init__.py,sha256=dZcFI9EBajH2KbCoNQWAFQ0
 claude_mpm/services/agents/management/agent_capabilities_generator.py,sha256=2j5yoyCXhsK41Bpr8gDAS6jXKhTI_lyYPkTa2djPls4,7002
 claude_mpm/services/agents/management/agent_management_service.py,sha256=ek8qGMHqyAb2kks4GG0GpS123dl-zyhRas9pnn6fUy8,23027
 claude_mpm/services/agents/memory/__init__.py,sha256=AcO-bZajiUBjnp1UNNMJyKFR3F2CDTgn5b0NEjN9Oiw,667
-claude_mpm/services/agents/memory/agent_memory_manager.py,sha256=YRjvzHtvp_HZy8UubRuO4gxQw29y1fZk4xzjOhQt1XQ,23920
+claude_mpm/services/agents/memory/agent_memory_manager.py,sha256=ITLrLTTvJcw5XOrHQOYhNgQsuqax6XsiTeSEv3zBi6M,23914
 claude_mpm/services/agents/memory/agent_persistence_service.py,sha256=mx67hEZtpMG-fom_qUvOL0U8HSWam1F55LJj4g4k3nw,2783
 claude_mpm/services/agents/memory/analyzer.py,sha256=dDpOquis1OjaHKr5IlHS125BpCFjxh8hng6kN-6eHFw,16973
 claude_mpm/services/agents/memory/content_manager.py,sha256=LifCY4VLFtWxwOPd8pKXWCTo2_p6xlGbHocSS9s6THo,13103
@@ -371,7 +371,7 @@ claude_mpm/services/socketio/__init__.py,sha256=FJ2BYTa1i_E9FUdjEuJ1FV1Joq9I5rNx
 claude_mpm/services/socketio/client_proxy.py,sha256=ISLDS0fXOi2a4txcZ9KTEk2Ywu4wrG08CmdYUlIezvU,6654
 claude_mpm/services/socketio/handlers/__init__.py,sha256=-lTRs1zdzDEf_QhT5ajE1_Z27MxKaFC4CzFtWxjK5ss,789
 claude_mpm/services/socketio/handlers/base.py,sha256=YaidwKRhDNhntQvfGTMX0XVkwdNfbYASopRJ9sFLbcA,4858
-claude_mpm/services/socketio/handlers/connection.py,sha256=l86hmJNUhLwYp01n-SaZ1meY1S0fT4iJEtK_0wH014w,12942
+claude_mpm/services/socketio/handlers/connection.py,sha256=6GCG_wWbxQrKYp1nNPhO2AGZzP5yYW5RtYPfUv_nB7E,24646
 claude_mpm/services/socketio/handlers/file.py,sha256=xYrzaZCQLkNvWvt3Ebnd7w66eaMhTr5ClxAvFMFDEIg,8431
 claude_mpm/services/socketio/handlers/git.py,sha256=sVmPKDC5VQb5ukzFelgTYu52M-wZntnANNNxrTewhVY,37861
 claude_mpm/services/socketio/handlers/hook.py,sha256=HrrcnRu7FfbbOFwLRTBxZEtXhVBBJatJlSTMvhhqiso,7658
@@ -379,9 +379,9 @@ claude_mpm/services/socketio/handlers/memory.py,sha256=0RltTwhXPhBZEpqSYFoXmVuSJ
 claude_mpm/services/socketio/handlers/project.py,sha256=_SbSRZ54IivtHWtfl4sKfbgRQL6sKaqVM5Rsxvql5JQ,789
 claude_mpm/services/socketio/handlers/registry.py,sha256=LiPfkRLGj0LLicWapRTnDzoqpPLr8UeE_TrXhZONqaU,6002
 claude_mpm/services/socketio/server/__init__.py,sha256=a5SYqKHCER3ger9dv4_P-RmLtND6pHd-2VFSrP04Gqo,640
-claude_mpm/services/socketio/server/broadcaster.py,sha256=IcFqD7A5Pv2WspG7-XfcEHUSxH48aUFwDa62xGd6r0E,9471
+claude_mpm/services/socketio/server/broadcaster.py,sha256=xRlEQBtIHxgnE2x7t0WN9PlPDaThudS-5FcZl2rFOc4,19063
 claude_mpm/services/socketio/server/core.py,sha256=mvIIV80WLOPWhs16JM17nA9Nwoo9j8anBc-sjaalp4c,14433
-claude_mpm/services/socketio/server/main.py,sha256=OXzkSfJ7xraQbLLGWH2_nWE_sTX9TPTObZMDW-fiLPs,11998
+claude_mpm/services/socketio/server/main.py,sha256=74tMkSW0kC3kgJjYhW89kjiwfYT6liIuUg78PbmH08M,12654
 claude_mpm/services/version_control/__init__.py,sha256=xj13GwrNw4t1KieGlmw62hj14HPj2BWP2Tlv-9E_tTE,1510
 claude_mpm/services/version_control/branch_strategy.py,sha256=XsmXwB98-zoTGKsM27fPS813tcKaJwgB7DWilgKKhio,23232
 claude_mpm/services/version_control/conflict_resolution.py,sha256=RM5cFxlEmvqS3SeCwMYAkhTu5UTIGlhI2Kgh2Yw7VO0,26381
@@ -410,9 +410,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=e74VlIPozCljZss_0SwLO3J1ZuIKRT9FrrFi
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=szbK9d29v_T6xE_KvW845WLKXbS_yYpXQscrSrSeldI,20937
 claude_mpm/validation/frontmatter_validator.py,sha256=Q_aTyjigfKZQG7eSwLtwMfd0h_eyS9FQAm59ZFf5VYA,7036
-claude_mpm-4.0.10.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.0.10.dist-info/METADATA,sha256=sCeWoa3vLWYxaX2_PRoWeyQraB037QdGukeFuEELcSc,11819
-claude_mpm-4.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.0.10.dist-info/entry_points.txt,sha256=uafLVeHm4AXrzvdR77fXO3a2MmvvfGtmVU2iY8uIPt8,403
-claude_mpm-4.0.10.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.0.10.dist-info/RECORD,,
+claude_mpm-4.0.11.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.0.11.dist-info/METADATA,sha256=cgnjym6qmxFMd0WUk4-n3OLlkkGGnzOk3ec6NJ1--cE,11819
+claude_mpm-4.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.0.11.dist-info/entry_points.txt,sha256=uafLVeHm4AXrzvdR77fXO3a2MmvvfGtmVU2iY8uIPt8,403
+claude_mpm-4.0.11.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.0.11.dist-info/RECORD,,