claude-mpm 4.1.6__py3-none-any.whl → 4.1.8__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_config_provider.py

@@ -90,8 +90,19 @@ class AgentConfigProvider:
             "engineer": {
                 **base_config,
                 "description": "Code implementation, development, and inline documentation",
-                "tags": '["engineer", "development", "coding", "implementation"]',
-                "tools": '["Read", "Write", "Edit", "MultiEdit", "Bash", "Grep", "Glob", "LS", "WebSearch", "TodoWrite"]',
+                "tags": ["engineer", "development", "coding", "implementation"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "MultiEdit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.2,
                 "when_to_use": [
                     "Code implementation needed",
@@ -109,14 +120,28 @@ class AgentConfigProvider:
                     "Refactor codebases",
                 ],
                 "primary_role": "Code implementation and development",
-                "specializations": '["coding", "debugging", "refactoring", "optimization"]',
+                "specializations": [
+                    "coding",
+                    "debugging",
+                    "refactoring",
+                    "optimization",
+                ],
                 "authority": "ALL code implementation decisions",
             },
             "qa": {
                 **base_config,
                 "description": "Quality assurance, testing, and validation",
-                "tags": '["qa", "testing", "quality", "validation"]',
-                "tools": '["Read", "Write", "Edit", "Bash", "Grep", "Glob", "LS", "TodoWrite"]',
+                "tags": ["qa", "testing", "quality", "validation"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "TodoWrite",
+                ],
                 "temperature": 0.1,
                 "when_to_use": [
                     "Testing needed",
@@ -134,14 +159,29 @@ class AgentConfigProvider:
                     "Validate quality",
                 ],
                 "primary_role": "Testing and quality assurance",
-                "specializations": '["testing", "validation", "quality-assurance", "coverage"]',
+                "specializations": [
+                    "testing",
+                    "validation",
+                    "quality-assurance",
+                    "coverage",
+                ],
                 "authority": "ALL testing and quality decisions",
             },
             "documentation": {
                 **base_config,
                 "description": "Documentation creation, maintenance, and changelog generation",
-                "tags": '["documentation", "writing", "changelog", "docs"]',
-                "tools": '["Read", "Write", "Edit", "MultiEdit", "Grep", "Glob", "LS", "WebSearch", "TodoWrite"]',
+                "tags": ["documentation", "writing", "changelog", "docs"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "MultiEdit",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.3,
                 "when_to_use": [
                     "Documentation updates needed",
@@ -159,14 +199,27 @@ class AgentConfigProvider:
                     "Maintain docs",
                 ],
                 "primary_role": "Documentation and technical writing",
-                "specializations": '["technical-writing", "changelog", "api-docs", "guides"]',
+                "specializations": [
+                    "technical-writing",
+                    "changelog",
+                    "api-docs",
+                    "guides",
+                ],
                 "authority": "ALL documentation decisions",
             },
             "research": {
                 **base_config,
                 "description": "Technical research, analysis, and investigation",
-                "tags": '["research", "analysis", "investigation", "evaluation"]',
-                "tools": '["Read", "Grep", "Glob", "LS", "WebSearch", "WebFetch", "TodoWrite"]',
+                "tags": ["research", "analysis", "investigation", "evaluation"],
+                "tools": [
+                    "Read",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "WebFetch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.4,
                 "when_to_use": [
                     "Technical research needed",
@@ -184,14 +237,27 @@ class AgentConfigProvider:
                     "Evidence-based recommendations",
                 ],
                 "primary_role": "Research and technical analysis",
-                "specializations": '["investigation", "analysis", "evaluation", "recommendations"]',
+                "specializations": [
+                    "investigation",
+                    "analysis",
+                    "evaluation",
+                    "recommendations",
+                ],
                 "authority": "ALL research decisions",
             },
             "security": {
                 **base_config,
                 "description": "Security analysis, vulnerability assessment, and protection",
-                "tags": '["security", "vulnerability", "protection", "audit"]',
-                "tools": '["Read", "Grep", "Glob", "LS", "Bash", "WebSearch", "TodoWrite"]',
+                "tags": ["security", "vulnerability", "protection", "audit"],
+                "tools": [
+                    "Read",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "Bash",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.1,
                 "when_to_use": [
                     "Security review needed",
@@ -209,14 +275,28 @@ class AgentConfigProvider:
                     "Threat modeling",
                 ],
                 "primary_role": "Security analysis and protection",
-                "specializations": '["vulnerability-assessment", "security-audit", "threat-modeling", "protection"]',
+                "specializations": [
+                    "vulnerability-assessment",
+                    "security-audit",
+                    "threat-modeling",
+                    "protection",
+                ],
                 "authority": "ALL security decisions",
             },
             "ops": {
                 **base_config,
                 "description": "Deployment, operations, and infrastructure management",
-                "tags": '["ops", "deployment", "infrastructure", "devops"]',
-                "tools": '["Read", "Write", "Edit", "Bash", "Grep", "Glob", "LS", "TodoWrite"]',
+                "tags": ["ops", "deployment", "infrastructure", "devops"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "TodoWrite",
+                ],
                 "temperature": 0.2,
                 "when_to_use": [
                     "Deployment configuration",
@@ -234,14 +314,29 @@ class AgentConfigProvider:
                     "Automate operations",
                 ],
                 "primary_role": "Operations and deployment management",
-                "specializations": '["deployment", "infrastructure", "automation", "monitoring"]',
+                "specializations": [
+                    "deployment",
+                    "infrastructure",
+                    "automation",
+                    "monitoring",
+                ],
                 "authority": "ALL operations decisions",
             },
             "data_engineer": {
                 **base_config,
                 "description": "Data pipeline management and AI API integrations",
-                "tags": '["data", "pipeline", "etl", "ai-integration"]',
-                "tools": '["Read", "Write", "Edit", "Bash", "Grep", "Glob", "LS", "WebSearch", "TodoWrite"]',
+                "tags": ["data", "pipeline", "etl", "ai-integration"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.2,
                 "when_to_use": [
                     "Data pipeline setup",
@@ -259,14 +354,19 @@ class AgentConfigProvider:
                     "Integrate AI services",
                 ],
                 "primary_role": "Data engineering and AI integration",
-                "specializations": '["data-pipelines", "etl", "database", "ai-integration"]',
+                "specializations": [
+                    "data-pipelines",
+                    "etl",
+                    "database",
+                    "ai-integration",
+                ],
                 "authority": "ALL data engineering decisions",
             },
             "version_control": {
                 **base_config,
                 "description": "Git operations, version management, and release coordination",
-                "tags": '["git", "version-control", "release", "branching"]',
-                "tools": '["Read", "Bash", "Grep", "Glob", "LS", "TodoWrite"]',
+                "tags": ["git", "version-control", "release", "branching"],
+                "tools": ["Read", "Bash", "Grep", "Glob", "LS", "TodoWrite"],
                 "temperature": 0.1,
                 "network_access": False,  # Git operations are local
                 "when_to_use": [
@@ -285,7 +385,7 @@ class AgentConfigProvider:
                     "Release coordination",
                 ],
                 "primary_role": "Version control and release management",
-                "specializations": '["git", "versioning", "branching", "releases"]',
+                "specializations": ["git", "versioning", "branching", "releases"],
                 "authority": "ALL version control decisions",
             },
         }
@@ -298,13 +398,13 @@ class AgentConfigProvider:
         return {
             **base_config,
             "description": f"{agent_name.title()} agent for specialized tasks",
-            "tags": f'["{agent_name}", "specialized", "mpm"]',
-            "tools": '["Read", "Write", "Edit", "Grep", "Glob", "LS", "TodoWrite"]',
+            "tags": [agent_name, "specialized", "mpm"],
+            "tools": ["Read", "Write", "Edit", "Grep", "Glob", "LS", "TodoWrite"],
             "temperature": 0.3,
             "when_to_use": [f"When {agent_name} expertise is needed"],
             "specialized_knowledge": [f"{agent_name.title()} domain knowledge"],
             "unique_capabilities": [f"{agent_name.title()} specialized operations"],
             "primary_role": f"{agent_name.title()} operations",
-            "specializations": f'["{agent_name}"]',
+            "specializations": [agent_name],
             "authority": f"ALL {agent_name} decisions",
         }

claude_mpm/services/diagnostics/checks/instructions_check.py

@@ -374,9 +374,7 @@ class InstructionsCheck(BaseDiagnosticCheck):
                 continue
 
         # Check for Claude Code specific content in INSTRUCTIONS.md
-        instructions_files = [
-            path for path in files if path.name == "INSTRUCTIONS.md"
-        ]
+        instructions_files = [path for path in files if path.name == "INSTRUCTIONS.md"]
         for path in instructions_files:
             try:
                 content = path.read_text(encoding="utf-8")

claude_mpm/services/event_bus/direct_relay.py

@@ -2,6 +2,16 @@
 
 This module provides a relay that connects EventBus directly to the
 Socket.IO server's broadcaster, avoiding the client loopback issue.
+
+IMPORTANT - Claude Event Format:
+Claude sends hook events with these REQUIRED fields:
+- hook_event_name: The event type (UserPromptSubmit, PreToolUse, PostToolUse, etc.)
+- hook_event_type: Usually same as hook_event_name
+- hook_input_data: Contains the actual event data
+- sessionId: Session identifier
+- timestamp: ISO format timestamp
+
+DO NOT use "event" or "type" fields - use "hook_event_name" instead!
 """
 
 import logging
@@ -37,9 +47,12 @@ class DirectSocketIORelay:
             "last_relay_time": None,
         }
         self.debug = logger.isEnabledFor(logging.DEBUG)
+        self.connection_retries = 0
+        self.max_retries = 10
+        self.retry_delay = 1.0  # Start with 1 second
 
     def start(self) -> None:
-        """Start the relay by subscribing to EventBus events."""
+        """Start the relay by subscribing to EventBus events with retry logic."""
         if not self.enabled:
             logger.warning("DirectSocketIORelay is disabled")
             return
@@ -59,14 +72,67 @@ class DirectSocketIORelay:
 
         # Add debug logging for verification
         logger.info("[DirectRelay] Subscribed to hook.* events on EventBus")
+
+        # Check and log broadcaster availability with retry logic
+        broadcaster_available = self._check_broadcaster_with_retry()
+
         logger.info(
-            f"[DirectRelay] Server broadcaster available: {self.server and self.server.broadcaster is not None}"
+            f"[DirectRelay] Server broadcaster available: {broadcaster_available}"
         )
+        if not broadcaster_available:
+            if not self.server:
+                logger.warning(
+                    "[DirectRelay] No server instance provided - events will not be relayed!"
+                )
+            elif not hasattr(self.server, "broadcaster"):
+                logger.warning(
+                    "[DirectRelay] Server has no broadcaster attribute - events will not be relayed!"
+                )
+            else:
+                logger.warning(
+                    "[DirectRelay] Server broadcaster is None after retries - events will not be relayed!"
+                )
+
         logger.info(f"[DirectRelay] EventBus instance: {self.event_bus is not None}")
 
         # Mark as connected after successful subscription
-        self.connected = True
-        logger.info("[DirectRelay] Started and subscribed to hook events")
+        self.connected = broadcaster_available
+        logger.info(f"[DirectRelay] Started with connection status: {self.connected}")
+
+    def _check_broadcaster_with_retry(self) -> bool:
+        """Check broadcaster availability with exponential backoff retry.
+
+        Returns:
+            True if broadcaster is available, False after max retries
+        """
+        import time
+
+        retry_delay = self.retry_delay
+
+        for attempt in range(self.max_retries):
+            broadcaster_available = (
+                self.server
+                and hasattr(self.server, "broadcaster")
+                and self.server.broadcaster is not None
+            )
+
+            if broadcaster_available:
+                self.connection_retries = 0  # Reset counter on success
+                return True
+
+            if attempt < self.max_retries - 1:
+                logger.info(
+                    f"[DirectRelay] Broadcaster not ready, retry {attempt + 1}/{self.max_retries} "
+                    f"in {retry_delay:.1f}s"
+                )
+                time.sleep(retry_delay)
+                retry_delay = min(retry_delay * 2, 30.0)  # Exponential backoff, max 30s
+            else:
+                logger.error(
+                    f"[DirectRelay] Broadcaster not available after {self.max_retries} attempts"
+                )
+
+        return False
 
     def _handle_hook_event(self, event_type: str, data: Any):
         """Internal method to handle hook events and broadcast them.
@@ -76,9 +142,28 @@ class DirectSocketIORelay:
             data: The event data
         """
         try:
-            # Log the event reception
+            # Enhanced debug logging for troubleshooting
             if self.debug:
                 logger.debug(f"[DirectRelay] Received event: {event_type}")
+                logger.debug(f"[DirectRelay] Event data type: {type(data).__name__}")
+                logger.debug(
+                    f"[DirectRelay] Event data keys: {list(data.keys()) if isinstance(data, dict) else 'not-dict'}"
+                )
+                logger.debug(
+                    f"[DirectRelay] Relay state - enabled: {self.enabled}, connected: {self.connected}"
+                )
+                logger.debug(
+                    f"[DirectRelay] Server state - has_server: {self.server is not None}, has_broadcaster: {self.server and hasattr(self.server, 'broadcaster') and self.server.broadcaster is not None}"
+                )
+
+            # Always log reception of important events
+            if event_type in [
+                "hook.pre_tool",
+                "hook.post_tool",
+                "hook.user_prompt",
+                "hook.subagent_stop",
+            ]:
+                logger.info(f"[DirectRelay] Processing important event: {event_type}")
 
             # Only relay hook events
             if event_type.startswith("hook."):
@@ -133,19 +218,69 @@ class DirectSocketIORelay:
 
                     # Use the full event_type (e.g., "hook.pre_tool") as the event name
                     # The normalizer handles dotted names and will extract type and subtype correctly
-                    self.server.broadcaster.broadcast_event(event_type, broadcast_data)
+                    try:
+                        self.server.broadcaster.broadcast_event(
+                            event_type, broadcast_data
+                        )
+                        self.stats["events_relayed"] += 1
+                        self.stats["last_relay_time"] = datetime.now().isoformat()
 
-                    self.stats["events_relayed"] += 1
-                    self.stats["last_relay_time"] = datetime.now().isoformat()
+                        # Reset retry counter on successful broadcast
+                        if self.connection_retries > 0:
+                            self.connection_retries = 0
+                            self.connected = True
+                            logger.info("[DirectRelay] Connection restored")
 
-                    if self.debug:
-                        logger.debug(
-                            f"[DirectRelay] Broadcasted hook event: {event_type}"
+                        if self.debug:
+                            logger.debug(
+                                f"[DirectRelay] Broadcasted hook event: {event_type}"
+                            )
+                    except Exception as broadcast_error:
+                        logger.error(
+                            f"[DirectRelay] Broadcast failed for {event_type}: {broadcast_error}"
                         )
+                        self.stats["events_failed"] += 1
+
+                        # Try to reconnect if broadcast fails
+                        if self.connection_retries < self.max_retries:
+                            self.connection_retries += 1
+                            self.connected = self._check_broadcaster_with_retry()
+                            if self.connected:
+                                # Retry the broadcast
+                                try:
+                                    self.server.broadcaster.broadcast_event(
+                                        event_type, broadcast_data
+                                    )
+                                    self.stats["events_relayed"] += 1
+                                    self.stats[
+                                        "events_failed"
+                                    ] -= 1  # Undo the failure count
+                                    logger.info(
+                                        f"[DirectRelay] Retry successful for {event_type}"
+                                    )
+                                except:
+                                    pass  # Already counted as failed
                 else:
+                    # Enhanced logging when broadcaster is not available
                     logger.warning(
                         f"[DirectRelay] Server broadcaster not available for {event_type}"
                     )
+                    if self.server:
+                        logger.warning(
+                            "[DirectRelay] Server exists but broadcaster is None"
+                        )
+                        logger.warning(
+                            f"[DirectRelay] Server type: {type(self.server).__name__}"
+                        )
+                        logger.warning(
+                            f"[DirectRelay] Server has broadcaster attr: {hasattr(self.server, 'broadcaster')}"
+                        )
+                        if hasattr(self.server, "broadcaster"):
+                            logger.warning(
+                                f"[DirectRelay] Broadcaster value: {self.server.broadcaster}"
+                            )
+                    else:
+                        logger.warning("[DirectRelay] Server is None")
                     self.stats["events_failed"] += 1
 
         except Exception as e:

claude_mpm/services/socketio/handlers/connection_handler.py

@@ -177,7 +177,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
         async def ping(sid):
             """Handle ping from client for health monitoring."""
             try:
-                # Update activity in connection manager
+                # Update activity in connection manager - CRITICAL for preventing stale connections
                 if self.server.connection_manager:
                     await self.server.connection_manager.update_activity(sid, "ping")
 
@@ -293,23 +293,8 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
             except Exception as e:
                 self.logger.error(f"Error getting connection stats for {sid}: {e}")
 
-        @sio.event
-        async def heartbeat(sid):
-            """Handle client heartbeat for connection monitoring."""
-            try:
-                # Update activity
-                if self.server.connection_manager:
-                    await self.server.connection_manager.update_activity(sid, "event")
-
-                # Send heartbeat response
-                await sio.emit(
-                    "heartbeat_response",
-                    {"timestamp": datetime.now().isoformat(), "status": "alive"},
-                    room=sid,
-                )
-
-            except Exception as e:
-                self.logger.error(f"Error handling heartbeat from {sid}: {e}")
+        # Heartbeat handler removed - Using Socket.IO's built-in ping/pong instead
+        # This prevents conflicting heartbeat systems that can cause disconnections
 
         self.logger.info("Enhanced connection event handlers registered")