claude-mpm 4.1.2__py3-none-any.whl → 4.1.4__py3-none-any.whl

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -1,38 +1,39 @@
 #!/usr/bin/env python3
-"""Optimized Claude Code hook handler with Socket.IO connection pooling.
-
-This handler now uses a connection pool for Socket.IO clients to reduce
-connection overhead and implement circuit breaker and batching patterns.
-
-WHY connection pooling approach:
-- Reduces connection setup/teardown overhead by 80%
-- Implements circuit breaker for resilience during outages
-- Provides micro-batching for high-frequency events
-- Maintains persistent connections for better performance
-- Falls back gracefully when Socket.IO unavailable
+"""Refactored Claude Code hook handler with modular service architecture.
+
+This handler uses a service-oriented architecture with:
+- StateManagerService: Manages state and delegation tracking
+- ConnectionManagerService: Handles SocketIO and EventBus connections
+- SubagentResponseProcessor: Processes complex subagent responses
+- DuplicateEventDetector: Detects and filters duplicate events
+
+WHY service-oriented approach:
+- Better separation of concerns and modularity
+- Easier testing and maintenance
+- Reduced file size from 1040 to ~400 lines
+- Clear service boundaries and responsibilities
 """
 
 import json
 import os
 import select
 import signal
-import subprocess
 import sys
 import threading
-import time
-from collections import deque
 from datetime import datetime
-from typing import Optional
 
 # Import extracted modules with fallback for direct execution
 try:
     # Try relative imports first (when imported as module)
-    # Use the modern SocketIOConnectionPool instead of the deprecated local one
-    from claude_mpm.core.socketio_pool import get_connection_pool
-
     from .event_handlers import EventHandlers
     from .memory_integration import MemoryHookManager
     from .response_tracking import ResponseTrackingManager
+    from .services import (
+        ConnectionManagerService,
+        DuplicateEventDetector,
+        StateManagerService,
+        SubagentResponseProcessor,
+    )
 except ImportError:
     # Fall back to absolute imports (when run directly)
     from pathlib import Path
@@ -40,46 +41,21 @@ except ImportError:
     # Add parent directory to path
     sys.path.insert(0, str(Path(__file__).parent))
 
-    # Try to import get_connection_pool from deprecated location
-    try:
-        from connection_pool import SocketIOConnectionPool
-
-        def get_connection_pool():
-            return SocketIOConnectionPool()
-
-    except ImportError:
-        get_connection_pool = None
-
     from event_handlers import EventHandlers
     from memory_integration import MemoryHookManager
     from response_tracking import ResponseTrackingManager
+    from services import (
+        ConnectionManagerService,
+        DuplicateEventDetector,
+        StateManagerService,
+        SubagentResponseProcessor,
+    )
 
-# Import EventNormalizer for consistent event formatting
-try:
-    from claude_mpm.services.socketio.event_normalizer import EventNormalizer
-except ImportError:
-    # Create a simple fallback EventNormalizer if import fails
-    class EventNormalizer:
-        def normalize(self, event_data):
-            """Simple fallback normalizer that returns event as-is."""
-            return type(
-                "NormalizedEvent",
-                (),
-                {
-                    "to_dict": lambda: {
-                        "event": "claude_event",
-                        "type": event_data.get("type", "unknown"),
-                        "subtype": event_data.get("subtype", "generic"),
-                        "timestamp": event_data.get(
-                            "timestamp", datetime.now().isoformat()
-                        ),
-                        "data": event_data.get("data", event_data),
-                    }
-                },
-            )
-
+# Debug mode is enabled by default for better visibility into hook processing
+# Set CLAUDE_MPM_HOOK_DEBUG=false to disable debug output
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
-# Import EventBus for decoupled event distribution
+# Import EventBus availability flag for backward compatibility with tests
 try:
     from claude_mpm.services.event_bus import EventBus
 
@@ -88,282 +64,52 @@ except ImportError:
     EVENTBUS_AVAILABLE = False
     EventBus = None
 
-# Import constants for configuration
+# Import get_connection_pool for backward compatibility with tests
 try:
-    from claude_mpm.core.constants import NetworkConfig, RetryConfig, TimeoutConfig
-except ImportError:
-    # Fallback values if constants module not available
-    class NetworkConfig:
-        SOCKETIO_PORT_RANGE = (8765, 8785)
-        RECONNECTION_DELAY = 0.5
-        SOCKET_WAIT_TIMEOUT = 1.0
-
-    class TimeoutConfig:
-        QUICK_TIMEOUT = 2.0
-
-    class RetryConfig:
-        MAX_RETRIES = 3
-        INITIAL_RETRY_DELAY = 0.1
-
-
-# Debug mode is enabled by default for better visibility into hook processing
-# Set CLAUDE_MPM_HOOK_DEBUG=false to disable debug output
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
-
-# Socket.IO import
-try:
-    import socketio
-
-    SOCKETIO_AVAILABLE = True
+    from claude_mpm.core.socketio_pool import get_connection_pool
 except ImportError:
-    SOCKETIO_AVAILABLE = False
-    socketio = None
+    get_connection_pool = None
 
 # Global singleton handler instance
 _global_handler = None
 _handler_lock = threading.Lock()
 
-# Track recent events to detect duplicates
-_recent_events = deque(maxlen=10)
-_events_lock = threading.Lock()
-
 
 class ClaudeHookHandler:
-    """Optimized hook handler with direct Socket.IO client.
+    """Refactored hook handler with service-oriented architecture.
 
-    WHY direct client approach:
-    - Simple and reliable synchronous operation
-    - No complex threading or async issues
-    - Fast connection reuse when possible
-    - Graceful fallback when Socket.IO unavailable
+    WHY service-oriented approach:
+    - Modular design with clear service boundaries
+    - Each service handles a specific responsibility
+    - Easier to test, maintain, and extend
+    - Reduced complexity in main handler class
     """
 
     def __init__(self):
-        # Track events for periodic cleanup
-        self.events_processed = 0
-        self.last_cleanup = time.time()
-        # Event normalizer for consistent event schema
-        self.event_normalizer = EventNormalizer()
-
-        # Initialize SocketIO connection pool for inter-process communication
-        # This sends events directly to the Socket.IO server in the daemon process
-        self.connection_pool = None
-        try:
-            self.connection_pool = get_connection_pool()
-            if DEBUG:
-                print("✅ Modern SocketIO connection pool initialized", file=sys.stderr)
-        except Exception as e:
-            if DEBUG:
-                print(
-                    f"⚠️ Failed to initialize SocketIO connection pool: {e}",
-                    file=sys.stderr,
-                )
-            self.connection_pool = None
-
-        # Initialize EventBus for in-process event distribution (optional)
-        self.event_bus = None
-        if EVENTBUS_AVAILABLE:
-            try:
-                self.event_bus = EventBus.get_instance()
-                if DEBUG:
-                    print("✅ EventBus initialized for hook handler", file=sys.stderr)
-            except Exception as e:
-                if DEBUG:
-                    print(f"⚠️ Failed to initialize EventBus: {e}", file=sys.stderr)
-                self.event_bus = None
-
-        # Maximum sizes for tracking
-        self.MAX_DELEGATION_TRACKING = 200
-        self.MAX_PROMPT_TRACKING = 100
-        self.MAX_CACHE_AGE_SECONDS = 300
-        self.CLEANUP_INTERVAL_EVENTS = 100
-
-        # Agent delegation tracking
-        # Store recent Task delegations: session_id -> agent_type
-        self.active_delegations = {}
-        # Use deque to limit memory usage (keep last 100 delegations)
-        self.delegation_history = deque(maxlen=100)
-        # Store delegation request data for response correlation: session_id -> request_data
-        self.delegation_requests = {}
-
-        # Git branch cache (to avoid repeated subprocess calls)
-        self._git_branch_cache = {}
-        self._git_branch_cache_time = {}
+        # Initialize services
+        self.state_manager = StateManagerService()
+        self.connection_manager = ConnectionManagerService()
+        self.duplicate_detector = DuplicateEventDetector()
 
         # Initialize extracted managers
         self.memory_hook_manager = MemoryHookManager()
         self.response_tracking_manager = ResponseTrackingManager()
         self.event_handlers = EventHandlers(self)
 
-        # Store current user prompts for comprehensive response tracking
-        self.pending_prompts = {}  # session_id -> prompt data
-
-    def _track_delegation(
-        self, session_id: str, agent_type: str, request_data: Optional[dict] = None
-    ):
-        """Track a new agent delegation with optional request data for response correlation."""
-        if DEBUG:
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - agent_type: {agent_type}", file=sys.stderr)
-            print(f"  - request_data provided: {bool(request_data)}", file=sys.stderr)
-            print(
-                f"  - delegation_requests size before: {len(self.delegation_requests)}",
-                file=sys.stderr,
-            )
-
-        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))
-
-            # Store request data for response tracking correlation
-            if request_data:
-                self.delegation_requests[session_id] = {
-                    "agent_type": agent_type,
-                    "request": request_data,
-                    "timestamp": datetime.now().isoformat(),
-                }
-                if DEBUG:
-                    print(
-                        f"  - ✅ Stored in delegation_requests[{session_id[:16]}...]",
-                        file=sys.stderr,
-                    )
-                    print(
-                        f"  - delegation_requests size after: {len(self.delegation_requests)}",
-                        file=sys.stderr,
-                    )
-
-            # Clean up old delegations (older than 5 minutes)
-            cutoff_time = datetime.now().timestamp() - 300
-            keys_to_remove = []
-            for sid in list(self.active_delegations.keys()):
-                # Check if this is an old entry by looking in history
-                found_recent = False
-                for hist_key, _ in reversed(self.delegation_history):
-                    if hist_key.startswith(sid):
-                        _, timestamp = hist_key.split(":", 1)
-                        if float(timestamp) > cutoff_time:
-                            found_recent = True
-                            break
-                if not found_recent:
-                    keys_to_remove.append(sid)
-
-            for key in keys_to_remove:
-                if key in self.active_delegations:
-                    del self.active_delegations[key]
-                if key in self.delegation_requests:
-                    del self.delegation_requests[key]
-
-    def _cleanup_old_entries(self):
-        """Clean up old entries to prevent memory growth."""
-        datetime.now().timestamp() - self.MAX_CACHE_AGE_SECONDS
-
-        # Clean up delegation tracking dictionaries
-        for storage in [self.active_delegations, self.delegation_requests]:
-            if len(storage) > self.MAX_DELEGATION_TRACKING:
-                # Keep only the most recent entries
-                sorted_keys = sorted(storage.keys())
-                excess = len(storage) - self.MAX_DELEGATION_TRACKING
-                for key in sorted_keys[:excess]:
-                    del storage[key]
-
-        # Clean up pending prompts
-        if len(self.pending_prompts) > self.MAX_PROMPT_TRACKING:
-            sorted_keys = sorted(self.pending_prompts.keys())
-            excess = len(self.pending_prompts) - self.MAX_PROMPT_TRACKING
-            for key in sorted_keys[:excess]:
-                del self.pending_prompts[key]
-
-        # Clean up git branch cache
-        expired_keys = [
-            key
-            for key, cache_time in self._git_branch_cache_time.items()
-            if datetime.now().timestamp() - cache_time > self.MAX_CACHE_AGE_SECONDS
-        ]
-        for key in expired_keys:
-            self._git_branch_cache.pop(key, None)
-            self._git_branch_cache_time.pop(key, None)
-
-    def _get_delegation_agent_type(self, session_id: str) -> str:
-        """Get the agent type for a session's active delegation."""
-        # First try exact session match
-        if session_id and session_id in self.active_delegations:
-            return self.active_delegations[session_id]
-
-        # Then try to find in 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: Optional[str] = None) -> str:
-        """Get git branch for the given directory with caching.
-
-        WHY caching approach:
-        - Avoids repeated subprocess calls which are expensive
-        - Caches results for 30 seconds per directory
-        - Falls back gracefully if git command fails
-        - Returns 'Unknown' for non-git directories
-        """
-        # Use current working directory if not specified
-        if not working_dir:
-            working_dir = os.getcwd()
-
-        # Check cache first (cache for 30 seconds)
-        current_time = datetime.now().timestamp()
-        cache_key = working_dir
-
-        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]
-
-        # Try to get git branch
-        try:
-            # Change to the working directory temporarily
-            original_cwd = os.getcwd()
-            os.chdir(working_dir)
-
-            # Run git command to get current branch
-            result = subprocess.run(
-                ["git", "branch", "--show-current"],
-                capture_output=True,
-                text=True,
-                timeout=TimeoutConfig.QUICK_TIMEOUT,
-                check=False,  # Quick timeout to avoid hanging
-            )
-
-            # Restore original directory
-            os.chdir(original_cwd)
+        # Initialize subagent processor with dependencies
+        self.subagent_processor = SubagentResponseProcessor(
+            self.state_manager, self.response_tracking_manager, self.connection_manager
+        )
 
-            if result.returncode == 0 and result.stdout.strip():
-                branch = result.stdout.strip()
-                # Cache the result
-                self._git_branch_cache[cache_key] = branch
-                self._git_branch_cache_time[cache_key] = current_time
-                return branch
-            # Not a git repository or no branch
-            self._git_branch_cache[cache_key] = "Unknown"
-            self._git_branch_cache_time[cache_key] = current_time
-            return "Unknown"
+        # Backward compatibility properties for tests
+        self.connection_pool = self.connection_manager.connection_pool
+        self.event_bus = self.connection_manager.event_bus
 
-        except (
-            subprocess.TimeoutExpired,
-            subprocess.CalledProcessError,
-            FileNotFoundError,
-            OSError,
-        ):
-            # Git not available or command failed
-            self._git_branch_cache[cache_key] = "Unknown"
-            self._git_branch_cache_time[cache_key] = current_time
-            return "Unknown"
+        # Expose state manager properties for backward compatibility
+        self.active_delegations = self.state_manager.active_delegations
+        self.delegation_history = self.state_manager.delegation_history
+        self.delegation_requests = self.state_manager.delegation_requests
+        self.pending_prompts = self.state_manager.pending_prompts
 
     def handle(self):
         """Process hook event with minimal overhead and timeout protection.
@@ -403,27 +149,17 @@ class ClaudeHookHandler:
                 return
 
             # Check for duplicate events (same event within 100ms)
-            global _recent_events, _events_lock
-            event_key = self._get_event_key(event)
-            current_time = time.time()
-
-            with _events_lock:
-                # Check if we've seen this event recently
-                for recent_key, recent_time in _recent_events:
-                    if recent_key == event_key and (current_time - recent_time) < 0.1:
-                        if DEBUG:
-                            print(
-                                f"[{datetime.now().isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
-                                file=sys.stderr,
-                            )
-                        # Still need to output continue for this invocation
-                        if not _continue_sent:
-                            self._continue_execution()
-                            _continue_sent = True
-                        return
-
-                # Not a duplicate, record it
-                _recent_events.append((event_key, current_time))
+            if self.duplicate_detector.is_duplicate(event):
+                if DEBUG:
+                    print(
+                        f"[{datetime.now().isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
+                        file=sys.stderr,
+                    )
+                # Still need to output continue for this invocation
+                if not _continue_sent:
+                    self._continue_execution()
+                    _continue_sent = True
+                return
 
             # Debug: Log that we're processing an event
             if DEBUG:
@@ -433,13 +169,12 @@ class ClaudeHookHandler:
                     file=sys.stderr,
                 )
 
-            # Increment event counter and perform periodic cleanup
-            self.events_processed += 1
-            if self.events_processed % self.CLEANUP_INTERVAL_EVENTS == 0:
-                self._cleanup_old_entries()
+            # Perform periodic cleanup if needed
+            if self.state_manager.increment_events_processed():
+                self.state_manager.cleanup_old_entries()
                 if DEBUG:
                     print(
-                        f"🧹 Performed cleanup after {self.events_processed} events",
+                        f"🧹 Performed cleanup after {self.state_manager.events_processed} events",
                         file=sys.stderr,
                     )
 
@@ -532,34 +267,9 @@ class ClaudeHookHandler:
                 if DEBUG:
                     print(f"Error handling {hook_type}: {e}", file=sys.stderr)
 
-    def _get_event_key(self, event: dict) -> str:
-        """Generate a unique key for an event to detect duplicates.
-
-        WHY: Claude Code may call the hook multiple times for the same event
-        because the hook is registered for multiple event types. We need to
-        detect and skip duplicate processing while still returning continue.
-        """
-        # Create a key from event type, session_id, and key data
-        hook_type = event.get("hook_event_name", "unknown")
-        session_id = event.get("session_id", "")
-
-        # Add type-specific data to make the key unique
-        if hook_type == "PreToolUse":
-            tool_name = event.get("tool_name", "")
-            # For some tools, include parameters to distinguish calls
-            if tool_name == "Task":
-                tool_input = event.get("tool_input", {})
-                agent = tool_input.get("subagent_type", "")
-                prompt_preview = (
-                    tool_input.get("prompt", "") or tool_input.get("description", "")
-                )[:50]
-                return f"{hook_type}:{session_id}:{tool_name}:{agent}:{prompt_preview}"
-            return f"{hook_type}:{session_id}:{tool_name}"
-        if hook_type == "UserPromptSubmit":
-            prompt_preview = event.get("prompt", "")[:50]
-            return f"{hook_type}:{session_id}:{prompt_preview}"
-        # For other events, just use type and session
-        return f"{hook_type}:{session_id}"
+    def handle_subagent_stop(self, event: dict):
+        """Delegate subagent stop processing to the specialized processor."""
+        self.subagent_processor.process_subagent_stop(event)
 
     def _continue_execution(self) -> None:
         """
@@ -570,407 +280,33 @@ class ClaudeHookHandler:
         """
         print(json.dumps({"action": "continue"}))
 
-    def _emit_socketio_event(self, namespace: str, event: str, data: dict):
-        """Emit event through both connection pool and EventBus.
-
-        WHY dual approach:
-        - Connection pool: Direct Socket.IO connection for inter-process communication
-        - EventBus: For in-process subscribers (if any)
-        - Ensures events reach the dashboard regardless of process boundaries
-        """
-        # Create event data for normalization
-        raw_event = {
-            "type": "hook",
-            "subtype": event,  # e.g., "user_prompt", "pre_tool", "subagent_stop"
-            "timestamp": datetime.now().isoformat(),
-            "data": data,
-            "source": "claude_hooks",  # Identify the source
-            "session_id": data.get("sessionId"),  # Include session if available
-        }
-
-        # Normalize the event using EventNormalizer for consistent schema
-        normalized_event = self.event_normalizer.normalize(raw_event, source="hook")
-        claude_event_data = normalized_event.to_dict()
-
-        # Log important events for debugging
-        if DEBUG and event in ["subagent_stop", "pre_tool"]:
-            if event == "subagent_stop":
-                agent_type = data.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
-                    file=sys.stderr,
-                )
-            elif event == "pre_tool" and data.get("tool_name") == "Task":
-                delegation = data.get("delegation_details", {})
-                agent_type = delegation.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'",
-                    file=sys.stderr,
-                )
-
-        # First, try to emit through direct Socket.IO connection pool
-        # This is the primary path for inter-process communication
-        if self.connection_pool:
-            try:
-                # Emit to Socket.IO server directly
-                self.connection_pool.emit("claude_event", claude_event_data)
-                if DEBUG:
-                    print(f"✅ Emitted via connection pool: {event}", file=sys.stderr)
-            except Exception as e:
-                if DEBUG:
-                    print(f"⚠️ Failed to emit via connection pool: {e}", file=sys.stderr)
-
-        # Also publish to EventBus for any in-process subscribers
-        if self.event_bus and EVENTBUS_AVAILABLE:
-            try:
-                # Publish to EventBus with topic format: hook.{event}
-                topic = f"hook.{event}"
-                self.event_bus.publish(topic, claude_event_data)
-                if DEBUG:
-                    print(f"✅ Published to EventBus: {topic}", file=sys.stderr)
-            except Exception as e:
-                if DEBUG:
-                    print(f"⚠️ Failed to publish to EventBus: {e}", file=sys.stderr)
-
-        # Warn if neither method is available
-        if not self.connection_pool and not self.event_bus and DEBUG:
-            print(f"⚠️ No event emission method available for: {event}", file=sys.stderr)
-
-    def handle_subagent_stop(self, event: dict):
-        """Handle subagent stop events with improved agent type detection.
-
-        WHY comprehensive subagent stop capture:
-        - Provides visibility into subagent lifecycle and delegation patterns
-        - Captures agent type, ID, reason, and results for analysis
-        - Enables tracking of delegation success/failure patterns
-        - Useful for understanding subagent performance and reliability
-        """
-        # Enhanced debug logging for session correlation
-        session_id = event.get("session_id", "")
-        if DEBUG:
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - event keys: {list(event.keys())}", file=sys.stderr)
-            print(
-                f"  - delegation_requests size: {len(self.delegation_requests)}",
-                file=sys.stderr,
-            )
-            # Show all stored session IDs for comparison
-            all_sessions = list(self.delegation_requests.keys())
-            if all_sessions:
-                print("  - Stored sessions (first 16 chars):", file=sys.stderr)
-                for sid in all_sessions[:10]:  # Show up to 10
-                    print(
-                        f"    - {sid[:16]}... (agent: {self.delegation_requests[sid].get('agent_type', 'unknown')})",
-                        file=sys.stderr,
-                    )
-            else:
-                print("  - No stored sessions in delegation_requests!", file=sys.stderr)
-
-        # First try to get agent type from our tracking
-        agent_type = (
-            self._get_delegation_agent_type(session_id) if session_id else "unknown"
-        )
-
-        # Fall back to event data if tracking didn't have it
-        if agent_type == "unknown":
-            agent_type = event.get("agent_type", event.get("subagent_type", "unknown"))
-
-        agent_id = event.get("agent_id", event.get("subagent_id", ""))
-        reason = event.get("reason", event.get("stop_reason", "unknown"))
-
-        # Try to infer agent type from other fields if still unknown
-        if agent_type == "unknown" and "task" in event:
-            task_desc = str(event.get("task", "")).lower()
-            if "research" in task_desc:
-                agent_type = "research"
-            elif "engineer" in task_desc or "code" in task_desc:
-                agent_type = "engineer"
-            elif "pm" in task_desc or "project" in task_desc:
-                agent_type = "pm"
-
-        # Always log SubagentStop events for debugging
-        if DEBUG or agent_type != "unknown":
-            print(
-                f"Hook handler: Processing SubagentStop - agent: '{agent_type}', session: '{session_id}', reason: '{reason}'",
-                file=sys.stderr,
-            )
-
-        # Get working directory and git branch
-        working_dir = event.get("cwd", "")
-        git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
-
-        # Try to extract structured response from output if available
-        output = event.get("output", "")
-        structured_response = None
-        if output:
-            try:
-                import re
-
-                json_match = re.search(
-                    r"```json\s*(\{.*?\})\s*```", str(output), re.DOTALL
-                )
-                if json_match:
-                    structured_response = json.loads(json_match.group(1))
-                    if DEBUG:
-                        print(
-                            f"Extracted structured response from {agent_type} agent in SubagentStop",
-                            file=sys.stderr,
-                        )
-            except (json.JSONDecodeError, AttributeError):
-                pass  # No structured response, that's okay
-
-        # Track agent response even without structured JSON
-        if DEBUG:
-            print(
-                f"  - response_tracking_enabled: {self.response_tracking_manager.response_tracking_enabled}",
-                file=sys.stderr,
-            )
-            print(
-                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}",
-                file=sys.stderr,
-            )
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - agent_type: {agent_type}", file=sys.stderr)
-            print(f"  - reason: {reason}", file=sys.stderr)
-            # Check if session exists in our storage
-            if session_id in self.delegation_requests:
-                print("  - ✅ Session found in delegation_requests", file=sys.stderr)
-                print(
-                    f"  - Stored agent: {self.delegation_requests[session_id].get('agent_type')}",
-                    file=sys.stderr,
-                )
-            else:
-                print(
-                    "  - ❌ Session NOT found in delegation_requests!", file=sys.stderr
-                )
-                print("  - Looking for partial match...", file=sys.stderr)
-                # Try to find partial matches
-                for stored_sid in list(self.delegation_requests.keys())[:10]:
-                    if stored_sid.startswith(session_id[:8]) or session_id.startswith(
-                        stored_sid[:8]
-                    ):
-                        print(
-                            f"    - Partial match found: {stored_sid[:16]}...",
-                            file=sys.stderr,
-                        )
-
-        if (
-            self.response_tracking_manager.response_tracking_enabled
-            and self.response_tracking_manager.response_tracker
-        ):
-            try:
-                # Get the original request data (with fuzzy matching fallback)
-                request_info = self.delegation_requests.get(session_id)
-
-                # If exact match fails, try partial matching
-                if not request_info and session_id:
-                    if DEBUG:
-                        print(
-                            f"  - Trying fuzzy match for session {session_id[:16]}...",
-                            file=sys.stderr,
-                        )
-                    # Try to find a session that matches the first 8-16 characters
-                    for stored_sid in list(self.delegation_requests.keys()):
-                        if (
-                            stored_sid.startswith(session_id[:8])
-                            or session_id.startswith(stored_sid[:8])
-                            or (
-                                len(session_id) >= 16
-                                and len(stored_sid) >= 16
-                                and stored_sid[:16] == session_id[:16]
-                            )
-                        ):
-                            if DEBUG:
-                                print(
-                                    f"  - \u2705 Fuzzy match found: {stored_sid[:16]}...",
-                                    file=sys.stderr,
-                                )
-                            request_info = self.delegation_requests.get(stored_sid)
-                            # Update the key to use the current session_id for consistency
-                            if request_info:
-                                self.delegation_requests[session_id] = request_info
-                                # Optionally remove the old key to avoid duplicates
-                                if stored_sid != session_id:
-                                    del self.delegation_requests[stored_sid]
-                            break
-
-                if DEBUG:
-                    print(
-                        f"  - request_info present: {bool(request_info)}",
-                        file=sys.stderr,
-                    )
-                    if request_info:
-                        print(
-                            "  - ✅ Found request data for response tracking",
-                            file=sys.stderr,
-                        )
-                        print(
-                            f"  - stored agent_type: {request_info.get('agent_type')}",
-                            file=sys.stderr,
-                        )
-                        print(
-                            f"  - request keys: {list(request_info.get('request', {}).keys())}",
-                            file=sys.stderr,
-                        )
-                    else:
-                        print(
-                            f"  - ❌ No request data found for session {session_id[:16]}...",
-                            file=sys.stderr,
-                        )
-
-                if request_info:
-                    # Use the output as the response
-                    response_text = (
-                        str(output)
-                        if output
-                        else f"Agent {agent_type} completed with reason: {reason}"
-                    )
-
-                    # Get the original request
-                    original_request = request_info.get("request", {})
-                    prompt = original_request.get("prompt", "")
-                    description = original_request.get("description", "")
-
-                    # Combine prompt and description
-                    full_request = prompt
-                    if description and description != prompt:
-                        if full_request:
-                            full_request += f"\n\nDescription: {description}"
-                        else:
-                            full_request = description
-
-                    if not full_request:
-                        full_request = f"Task delegation to {agent_type} agent"
-
-                    # Prepare metadata
-                    metadata = {
-                        "exit_code": event.get("exit_code", 0),
-                        "success": reason in ["completed", "finished", "done"],
-                        "has_error": reason
-                        in ["error", "timeout", "failed", "blocked"],
-                        "duration_ms": event.get("duration_ms"),
-                        "working_directory": working_dir,
-                        "git_branch": git_branch,
-                        "timestamp": datetime.now().isoformat(),
-                        "event_type": "subagent_stop",
-                        "reason": reason,
-                        "original_request_timestamp": request_info.get("timestamp"),
-                    }
-
-                    # Add structured response if available
-                    if structured_response:
-                        metadata["structured_response"] = structured_response
-                        metadata["task_completed"] = structured_response.get(
-                            "task_completed", False
-                        )
-
-                        # Check for MEMORIES field and process if present
-                        if structured_response.get("MEMORIES"):
-                            memories = structured_response["MEMORIES"]
-                            if DEBUG:
-                                print(
-                                    f"Found MEMORIES field in {agent_type} response with {len(memories)} items",
-                                    file=sys.stderr,
-                                )
-                            # The memory will be processed by extract_and_update_memory
-                            # which is called by the memory hook service
-
-                    # Track the response
-                    file_path = (
-                        self.response_tracking_manager.response_tracker.track_response(
-                            agent_name=agent_type,
-                            request=full_request,
-                            response=response_text,
-                            session_id=session_id,
-                            metadata=metadata,
-                        )
-                    )
-
-                    if file_path and DEBUG:
-                        print(
-                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
-                            file=sys.stderr,
-                        )
-
-                    # Clean up the request data
-                    if session_id in self.delegation_requests:
-                        del self.delegation_requests[session_id]
-
-                elif DEBUG:
-                    print(
-                        f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}",
-                        file=sys.stderr,
-                    )
-
-            except Exception as e:
-                if DEBUG:
-                    print(
-                        f"❌ Failed to track response on SubagentStop: {e}",
-                        file=sys.stderr,
-                    )
+    # Delegation methods for compatibility with event_handlers
+    def _track_delegation(self, session_id: str, agent_type: str, request_data=None):
+        """Track delegation through state manager."""
+        self.state_manager.track_delegation(session_id, agent_type, request_data)
 
-        subagent_stop_data = {
-            "agent_type": agent_type,
-            "agent_id": agent_id,
-            "reason": reason,
-            "session_id": session_id,
-            "working_directory": working_dir,
-            "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
-            "is_successful_completion": reason in ["completed", "finished", "done"],
-            "is_error_termination": reason in ["error", "timeout", "failed", "blocked"],
-            "is_delegation_related": agent_type
-            in ["research", "engineer", "pm", "ops", "qa", "documentation", "security"],
-            "has_results": bool(event.get("results") or event.get("output")),
-            "duration_context": event.get("duration_ms"),
-            "hook_event_name": "SubagentStop",  # Explicitly set for dashboard
-        }
-
-        # Add structured response data if available
-        if structured_response:
-            subagent_stop_data["structured_response"] = {
-                "task_completed": structured_response.get("task_completed", False),
-                "instructions": structured_response.get("instructions", ""),
-                "results": structured_response.get("results", ""),
-                "files_modified": structured_response.get("files_modified", []),
-                "tools_used": structured_response.get("tools_used", []),
-                "remember": structured_response.get("remember"),
-                "MEMORIES": structured_response.get(
-                    "MEMORIES"
-                ),  # Complete memory replacement
-            }
+    def _get_delegation_agent_type(self, session_id: str) -> str:
+        """Get delegation agent type through state manager."""
+        return self.state_manager.get_delegation_agent_type(session_id)
 
-            # Log if MEMORIES field is present
-            if structured_response.get("MEMORIES"):
-                if DEBUG:
-                    memories_count = len(structured_response["MEMORIES"])
-                    print(
-                        f"Agent {agent_type} returned MEMORIES field with {memories_count} items",
-                        file=sys.stderr,
-                    )
+    def _get_git_branch(self, working_dir=None) -> str:
+        """Get git branch through state manager."""
+        return self.state_manager.get_git_branch(working_dir)
 
-        # Debug log the processed data
-        if DEBUG:
-            print(
-                f"SubagentStop processed data: agent_type='{agent_type}', session_id='{session_id}'",
-                file=sys.stderr,
-            )
+    def _emit_socketio_event(self, namespace: str, event: str, data: dict):
+        """Emit event through connection manager."""
+        self.connection_manager.emit_event(namespace, event, data)
 
-        # Emit to /hook namespace with high priority
-        self._emit_socketio_event("/hook", "subagent_stop", subagent_stop_data)
+    def _get_event_key(self, event: dict) -> str:
+        """Generate event key through duplicate detector (backward compatibility)."""
+        return self.duplicate_detector.generate_event_key(event)
 
     def __del__(self):
         """Cleanup on handler destruction."""
-        # Clean up connection pool if it exists
-        if hasattr(self, "connection_pool") and self.connection_pool:
+        # Clean up connection manager if it exists
+        if hasattr(self, "connection_manager") and self.connection_manager:
             try:
-                self.connection_pool.cleanup()
+                self.connection_manager.cleanup()
             except:
                 pass  # Ignore cleanup errors during destruction