claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -7,12 +7,21 @@ Claude Code hook events.
 
 import os
 import re
-import subprocess
-import sys
+import subprocess  # nosec B404 - subprocess used for safe claude CLI version checking only
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
+# Import _log helper to avoid stderr writes (which cause hook errors)
+try:
+    from .hook_handler import _log
+except ImportError:
+    # Fallback for direct execution
+    def _log(message: str) -> None:
+        """Fallback logger when hook_handler not available."""
+
+
 # Import tool analysis with fallback for direct execution
 try:
     # Try relative import first (when imported as module)
@@ -33,8 +42,8 @@ except ImportError:
         extract_tool_results,
     )
 
-# Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Debug mode - MUST match hook_handler.py default (false) to prevent stderr writes
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Import constants for configuration
 try:
@@ -94,22 +103,37 @@ class EventHandlers:
         }
 
         # Store prompt for comprehensive response tracking if enabled
-        if (
-            self.hook_handler.response_tracking_manager.response_tracking_enabled
-            and self.hook_handler.response_tracking_manager.track_all_interactions
-        ):
-            session_id = event.get("session_id", "")
-            if session_id:
-                self.hook_handler.pending_prompts[session_id] = {
-                    "prompt": prompt,
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "working_directory": working_dir,
-                }
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if (
+                rtm
+                and getattr(rtm, "response_tracking_enabled", False)
+                and getattr(rtm, "track_all_interactions", False)
+            ):
+                session_id = event.get("session_id", "")
+                if session_id:
+                    pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+                    pending_prompts[session_id] = {
+                        "prompt": prompt,
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                        "working_directory": working_dir,
+                    }
+                    if DEBUG:
+                        _log(
+                            f"Stored prompt for comprehensive tracking: session {session_id[:8]}..."
+                        )
+        except Exception:  # nosec B110
+            # Response tracking is optional - silently continue if it fails
+            pass
+
+        # Record user message for auto-pause if active
+        auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+        if auto_pause and auto_pause.is_pause_active():
+            try:
+                auto_pause.on_user_message(prompt)
+            except Exception as e:
                 if DEBUG:
-                    print(
-                        f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
-                        file=sys.stderr,
-                    )
+                    _log(f"Auto-pause user message recording error: {e}")
 
         # Emit normalized event (namespace no longer needed with normalized events)
         self.hook_handler._emit_socketio_event("", "user_prompt", prompt_data)
@@ -125,15 +149,15 @@ class EventHandlers:
         # 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)
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - event keys: {list(event.keys())}")
 
         tool_name = event.get("tool_name", "")
         tool_input = event.get("tool_input", {})
 
+        # Generate unique tool call ID for correlation with post_tool event
+        tool_call_id = str(uuid.uuid4())
+
         # Extract key parameters based on tool type
         tool_params = extract_tool_parameters(tool_name, tool_input)
 
@@ -144,6 +168,8 @@ class EventHandlers:
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
 
+        timestamp = datetime.now(timezone.utc).isoformat()
+
         pre_tool_data = {
             "tool_name": tool_name,
             "operation_type": operation_type,
@@ -151,21 +177,57 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "timestamp": timestamp,
             "parameter_count": len(tool_input) if isinstance(tool_input, dict) else 0,
             "is_file_operation": tool_name
             in ["Write", "Edit", "MultiEdit", "Read", "LS", "Glob"],
             "is_execution": tool_name in ["Bash", "NotebookEdit"],
             "is_delegation": tool_name == "Task",
             "security_risk": assess_security_risk(tool_name, tool_input),
+            "correlation_id": tool_call_id,  # Add correlation_id for pre/post correlation
         }
 
+        # Store tool_call_id using CorrelationManager for cross-process retrieval
+        if session_id:
+            from .correlation_manager import CorrelationManager
+
+            CorrelationManager.store(session_id, tool_call_id, tool_name)
+            if DEBUG:
+                _log(
+                    f"  - Generated tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}..."
+                )
+
         # Add delegation-specific data if this is a Task tool
         if tool_name == "Task" and isinstance(tool_input, dict):
             self._handle_task_delegation(tool_input, pre_tool_data, session_id)
 
+        # Record tool call for auto-pause if active
+        auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+        if auto_pause and auto_pause.is_pause_active():
+            try:
+                auto_pause.on_tool_call(tool_name, tool_input)
+            except Exception as e:
+                if DEBUG:
+                    _log(f"Auto-pause tool recording error: {e}")
+
         self.hook_handler._emit_socketio_event("", "pre_tool", pre_tool_data)
 
+        # Handle TodoWrite specially - emit dedicated todo_updated event
+        # WHY: Frontend expects todo_updated events for dashboard display
+        # The broadcaster.todo_updated() method exists but was never called
+        if tool_name == "TodoWrite" and tool_params.get("todos"):
+            todo_data = {
+                "todos": tool_params["todos"],
+                "total_count": len(tool_params["todos"]),
+                "session_id": session_id,
+                "timestamp": timestamp,
+            }
+            self.hook_handler._emit_socketio_event("", "todo_updated", todo_data)
+            if DEBUG:
+                _log(
+                    f"  - Emitted todo_updated event with {len(tool_params['todos'])} todos for session {session_id[:8]}..."
+                )
+
     def _handle_task_delegation(
         self, tool_input: dict, pre_tool_data: dict, session_id: str
     ):
@@ -204,12 +266,9 @@ class EventHandlers:
 
         # Track this delegation for SubagentStop correlation and response tracking
         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"  - raw_agent_type: {raw_agent_type}", file=sys.stderr)
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - agent_type: {agent_type}")
+            _log(f"  - raw_agent_type: {raw_agent_type}")
 
         if session_id and agent_type != "unknown":
             # Prepare request data for response tracking correlation
@@ -221,27 +280,27 @@ class EventHandlers:
             self.hook_handler._track_delegation(session_id, agent_type, request_data)
 
             if DEBUG:
-                print("  - Delegation tracked successfully", file=sys.stderr)
-                print(
-                    f"  - Request data keys: {list(request_data.keys())}",
-                    file=sys.stderr,
-                )
-                print(
-                    f"  - delegation_requests size: {len(self.hook_handler.delegation_requests)}",
-                    file=sys.stderr,
+                _log("  - Delegation tracked successfully")
+                _log(f"  - Request data keys: {list(request_data.keys())}")
+                delegation_requests = getattr(
+                    self.hook_handler, "delegation_requests", {}
                 )
+                _log(f"  - delegation_requests size: {len(delegation_requests)}")
 
             # Log important delegations for debugging
             if DEBUG or agent_type in ["research", "engineer", "qa", "documentation"]:
-                print(
-                    f"Hook handler: Task delegation started - agent: '{agent_type}', session: '{session_id}'",
-                    file=sys.stderr,
+                _log(
+                    f"Hook handler: Task delegation started - agent: '{agent_type}', session: '{session_id}'"
                 )
 
         # Trigger memory pre-delegation hook
-        self.hook_handler.memory_hook_manager.trigger_pre_delegation_hook(
-            agent_type, tool_input, session_id
-        )
+        try:
+            mhm = getattr(self.hook_handler, "memory_hook_manager", None)
+            if mhm and hasattr(mhm, "trigger_pre_delegation_hook"):
+                mhm.trigger_pre_delegation_hook(agent_type, tool_input, session_id)
+        except Exception:  # nosec B110
+            # Memory hooks are optional
+            pass
 
         # Emit a subagent_start event for better tracking
         subagent_start_data = {
@@ -301,10 +360,10 @@ class EventHandlers:
                     )
 
                 if DEBUG:
-                    print(f"  - Agent prompt logged for {agent_type}", file=sys.stderr)
+                    _log(f"  - Agent prompt logged for {agent_type}")
         except Exception as e:
             if DEBUG:
-                print(f"  - Could not log agent prompt: {e}", file=sys.stderr)
+                _log(f"  - Could not log agent prompt: {e}")
 
     def _get_git_branch(self, working_dir: Optional[str] = None) -> str:
         """Get git branch for the given directory with caching."""
@@ -332,7 +391,7 @@ class EventHandlers:
             os.chdir(working_dir)
 
             # Run git command to get current branch
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["git", "branch", "--show-current"],
                 capture_output=True,
                 text=True,
@@ -375,6 +434,7 @@ class EventHandlers:
         """
         tool_name = event.get("tool_name", "")
         exit_code = event.get("exit_code", 0)
+        session_id = event.get("session_id", "")
 
         # Extract result data
         result_data = extract_tool_results(event)
@@ -386,6 +446,15 @@ class EventHandlers:
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
 
+        # Retrieve tool_call_id using CorrelationManager for cross-process correlation
+        from .correlation_manager import CorrelationManager
+
+        tool_call_id = CorrelationManager.retrieve(session_id) if session_id else None
+        if DEBUG and tool_call_id:
+            _log(
+                f"  - Retrieved tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}..."
+            )
+
         post_tool_data = {
             "tool_name": tool_name,
             "exit_code": exit_code,
@@ -399,7 +468,7 @@ class EventHandlers:
             ),
             "duration_ms": duration,
             "result_summary": result_data,
-            "session_id": event.get("session_id", ""),
+            "session_id": session_id,
             "working_directory": working_dir,
             "git_branch": git_branch,
             "timestamp": datetime.now(timezone.utc).isoformat(),
@@ -412,20 +481,42 @@ class EventHandlers:
             ),
         }
 
+        # Include full output for file operations (Read, Edit, Write)
+        # so frontend can display file content
+        if tool_name in ("Read", "Edit", "Write", "Grep", "Glob") and "output" in event:
+            post_tool_data["output"] = event["output"]
+
+        # Add correlation_id if available for correlation with pre_tool
+        if tool_call_id:
+            post_tool_data["correlation_id"] = tool_call_id
+
         # Handle Task delegation completion for memory hooks and response tracking
         if tool_name == "Task":
             session_id = event.get("session_id", "")
             agent_type = self.hook_handler._get_delegation_agent_type(session_id)
 
             # Trigger memory post-delegation hook
-            self.hook_handler.memory_hook_manager.trigger_post_delegation_hook(
-                agent_type, event, session_id
-            )
+            try:
+                mhm = getattr(self.hook_handler, "memory_hook_manager", None)
+                if mhm and hasattr(mhm, "trigger_post_delegation_hook"):
+                    mhm.trigger_post_delegation_hook(agent_type, event, session_id)
+            except Exception:  # nosec B110
+                # Memory hooks are optional
+                pass
 
             # Track agent response if response tracking is enabled
-            self.hook_handler.response_tracking_manager.track_agent_response(
-                session_id, agent_type, event, self.hook_handler.delegation_requests
-            )
+            try:
+                rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+                if rtm and hasattr(rtm, "track_agent_response"):
+                    delegation_requests = getattr(
+                        self.hook_handler, "delegation_requests", {}
+                    )
+                    rtm.track_agent_response(
+                        session_id, agent_type, event, delegation_requests
+                    )
+            except Exception:  # nosec B110
+                # Response tracking is optional
+                pass
 
         self.hook_handler._emit_socketio_event("", "post_tool", post_tool_data)
 
@@ -485,10 +576,64 @@ class EventHandlers:
         if DEBUG:
             self._log_stop_event_debug(event, session_id, metadata)
 
+        # Auto-pause integration (independent of response tracking)
+        # WHY HERE: Auto-pause must work even when response_tracking is disabled
+        # Extract usage data directly from event and trigger auto-pause if thresholds crossed
+        if "usage" in event:
+            auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+            if auto_pause:
+                try:
+                    usage_data = event["usage"]
+                    metadata["usage"] = {
+                        "input_tokens": usage_data.get("input_tokens", 0),
+                        "output_tokens": usage_data.get("output_tokens", 0),
+                        "cache_creation_input_tokens": usage_data.get(
+                            "cache_creation_input_tokens", 0
+                        ),
+                        "cache_read_input_tokens": usage_data.get(
+                            "cache_read_input_tokens", 0
+                        ),
+                    }
+
+                    threshold_crossed = auto_pause.on_usage_update(metadata["usage"])
+                    if threshold_crossed:
+                        warning = auto_pause.emit_threshold_warning(threshold_crossed)
+                        # CRITICAL: Never write to stderr unconditionally - causes hook errors
+                        # Use _log() instead which only writes to file if DEBUG=true
+                        from . import _log
+
+                        _log(f"⚠️  Auto-pause threshold crossed: {warning}")
+
+                        if DEBUG:
+                            _log(
+                                f"  - Auto-pause threshold crossed: {threshold_crossed}"
+                            )
+                except Exception as e:
+                    if DEBUG:
+                        _log(f"Auto-pause error in handle_stop_fast: {e}")
+
+                # Finalize pause session if active
+                try:
+                    if auto_pause.is_pause_active():
+                        session_file = auto_pause.on_session_end()
+                        if session_file:
+                            if DEBUG:
+                                _log(
+                                    f"✅ Auto-pause session finalized: {session_file.name}"
+                                )
+                except Exception as e:
+                    if DEBUG:
+                        _log(f"❌ Failed to finalize auto-pause session: {e}")
+
         # Track response if enabled
-        self.hook_handler.response_tracking_manager.track_stop_response(
-            event, session_id, metadata, self.hook_handler.pending_prompts
-        )
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if rtm and hasattr(rtm, "track_stop_response"):
+                pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+                rtm.track_stop_response(event, session_id, metadata, pending_prompts)
+        except Exception:  # nosec B110
+            # Response tracking is optional
+            pass
 
         # Emit stop event to Socket.IO
         self._emit_stop_event(event, session_id, metadata)
@@ -511,21 +656,24 @@ class EventHandlers:
         self, event: dict, session_id: str, metadata: dict
     ) -> None:
         """Log debug information for stop events."""
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            tracking_enabled = (
+                getattr(rtm, "response_tracking_enabled", False) if rtm else False
+            )
+            tracker_exists = (
+                getattr(rtm, "response_tracker", None) is not None if rtm else False
+            )
 
-        print(
-            f"  - response_tracking_enabled: {self.hook_handler.response_tracking_manager.response_tracking_enabled}",
-            file=sys.stderr,
-        )
-        print(
-            f"  - response_tracker exists: {self.hook_handler.response_tracking_manager.response_tracker is not None}",
-            file=sys.stderr,
-        )
-        print(
-            f"  - session_id: {session_id[:8] if session_id else 'None'}...",
-            file=sys.stderr,
-        )
-        print(f"  - reason: {metadata['reason']}", file=sys.stderr)
-        print(f"  - stop_type: {metadata['stop_type']}", file=sys.stderr)
+            _log(f"  - response_tracking_enabled: {tracking_enabled}")
+            _log(f"  - response_tracker exists: {tracker_exists}")
+        except Exception:  # nosec B110
+            # If debug logging fails, just skip it
+            pass
+
+        _log(f"  - session_id: {session_id[:8] if session_id else 'None'}...")
+        _log(f"  - reason: {metadata['reason']}")
+        _log(f"  - stop_type: {metadata['stop_type']}")
 
     def _emit_stop_event(self, event: dict, session_id: str, metadata: dict) -> None:
         """Emit stop event data to Socket.IO."""
@@ -567,25 +715,29 @@ class EventHandlers:
         git_branch: str,
     ):
         """Handle response tracking for subagent stop events with fuzzy matching."""
-        if not (
-            self.hook_handler.response_tracking_manager.response_tracking_enabled
-            and self.hook_handler.response_tracking_manager.response_tracker
-        ):
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if not (
+                rtm
+                and getattr(rtm, "response_tracking_enabled", False)
+                and getattr(rtm, "response_tracker", None)
+            ):
+                return
+        except Exception:
+            # Response tracking is optional
             return
 
         try:
             # Get the original request data (with fuzzy matching fallback)
-            request_info = self.hook_handler.delegation_requests.get(session_id)
+            delegation_requests = getattr(self.hook_handler, "delegation_requests", {})
+            request_info = delegation_requests.get(session_id)  # nosec B113
 
             # 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,
-                    )
+                    _log(f"  - Trying fuzzy match for session {session_id[:16]}...")
                 # Try to find a session that matches the first 8-16 characters
-                for stored_sid in list(self.hook_handler.delegation_requests.keys()):
+                for stored_sid in list(delegation_requests.keys()):
                     if (
                         stored_sid.startswith(session_id[:8])
                         or session_id.startswith(stored_sid[:8])
@@ -596,21 +748,14 @@ class EventHandlers:
                         )
                     ):
                         if DEBUG:
-                            print(
-                                f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
-                                file=sys.stderr,
-                            )
-                        request_info = self.hook_handler.delegation_requests.get(
-                            stored_sid
-                        )
+                            _log(f"  - ✅ Fuzzy match found: {stored_sid[:16]}...")
+                        request_info = delegation_requests.get(stored_sid)  # nosec B113
                         # Update the key to use the current session_id for consistency
                         if request_info:
-                            self.hook_handler.delegation_requests[session_id] = (
-                                request_info
-                            )
+                            delegation_requests[session_id] = request_info
                             # Optionally remove the old key to avoid duplicates
                             if stored_sid != session_id:
-                                del self.hook_handler.delegation_requests[stored_sid]
+                                del delegation_requests[stored_sid]
                         break
 
             if request_info:
@@ -658,35 +803,39 @@ class EventHandlers:
                     )
 
                 # Track the response
-                file_path = self.hook_handler.response_tracking_manager.response_tracker.track_response(
-                    agent_name=agent_type,
-                    request=full_request,
-                    response=response_text,
-                    session_id=session_id,
-                    metadata=metadata,
+                rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+                response_tracker = (
+                    getattr(rtm, "response_tracker", None) if rtm else None
                 )
-
-                if file_path and DEBUG:
-                    print(
-                        f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
-                        file=sys.stderr,
+                if response_tracker and hasattr(response_tracker, "track_response"):
+                    file_path = 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:
+                        _log(
+                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}"
+                        )
+
                 # Clean up the request data
-                if session_id in self.hook_handler.delegation_requests:
-                    del self.hook_handler.delegation_requests[session_id]
+                delegation_requests = getattr(
+                    self.hook_handler, "delegation_requests", {}
+                )
+                if session_id in delegation_requests:
+                    del delegation_requests[session_id]
 
             elif DEBUG:
-                print(
-                    f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}",
-                    file=sys.stderr,
+                _log(
+                    f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}"
                 )
 
         except Exception as e:
             if DEBUG:
-                print(
-                    f"❌ Failed to track response on SubagentStop: {e}", file=sys.stderr
-                )
+                _log(f"❌ Failed to track response on SubagentStop: {e}")
 
     def handle_assistant_response(self, event):
         """Handle assistant response events for comprehensive response tracking.
@@ -696,11 +845,24 @@ class EventHandlers:
         - Captures response content and metadata for analysis
         - Enables tracking of conversation flow and response patterns
         - Essential for comprehensive monitoring of Claude interactions
+        - Scans for delegation anti-patterns and creates autotodos
         """
         # Track the response for logging
-        self.hook_handler.response_tracking_manager.track_assistant_response(
-            event, self.hook_handler.pending_prompts
-        )
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if rtm and hasattr(rtm, "track_assistant_response"):
+                pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+                rtm.track_assistant_response(event, pending_prompts)
+        except Exception:  # nosec B110
+            # Response tracking is optional
+            pass
+
+        # Scan response for delegation anti-patterns and create autotodos
+        try:
+            self._scan_for_delegation_patterns(event)
+        except Exception as e:  # nosec B110
+            if DEBUG:
+                _log(f"Delegation scanning error: {e}")
 
         # Get working directory and git branch
         working_dir = event.get("cwd", "")
@@ -730,26 +892,215 @@ class EventHandlers:
         }
 
         # Check if this is a response to a tracked prompt
-        if session_id in self.hook_handler.pending_prompts:
-            prompt_data = self.hook_handler.pending_prompts[session_id]
-            assistant_response_data["original_prompt"] = prompt_data.get("prompt", "")[
-                :200
-            ]
-            assistant_response_data["prompt_timestamp"] = prompt_data.get(
-                "timestamp", ""
-            )
-            assistant_response_data["is_tracked_response"] = True
-        else:
+        try:
+            pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+            if session_id in pending_prompts:
+                prompt_data = pending_prompts[session_id]
+                assistant_response_data["original_prompt"] = prompt_data.get(
+                    "prompt", ""
+                )[:200]
+                assistant_response_data["prompt_timestamp"] = prompt_data.get(
+                    "timestamp", ""
+                )
+                assistant_response_data["is_tracked_response"] = True
+            else:
+                assistant_response_data["is_tracked_response"] = False
+        except Exception:
+            # If prompt lookup fails, just mark as not tracked
             assistant_response_data["is_tracked_response"] = False
 
         # Debug logging
         if DEBUG:
-            print(
-                f"Hook handler: Processing AssistantResponse - session: '{session_id}', response_length: {len(response_text)}",
-                file=sys.stderr,
+            _log(
+                f"Hook handler: Processing AssistantResponse - session: '{session_id}', response_length: {len(response_text)}"
             )
 
+        # Record assistant response for auto-pause if active
+        auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+        if auto_pause and auto_pause.is_pause_active():
+            try:
+                # Summarize response to first 200 chars
+                summary = (
+                    response_text[:200] + "..."
+                    if len(response_text) > 200
+                    else response_text
+                )
+                auto_pause.on_assistant_response(summary)
+            except Exception as e:
+                if DEBUG:
+                    _log(f"Auto-pause response recording error: {e}")
+
         # Emit normalized event
         self.hook_handler._emit_socketio_event(
             "", "assistant_response", assistant_response_data
         )
+
+    def handle_session_start_fast(self, event):
+        """Handle session start events for tracking conversation sessions.
+
+        WHY track session starts:
+        - Provides visibility into new conversation sessions
+        - Enables tracking of session lifecycle and duration
+        - Useful for monitoring concurrent sessions and resource usage
+        - Auto-inject pending autotodos if enabled in config
+        """
+        session_id = event.get("session_id", "")
+        working_dir = event.get("cwd", "")
+        git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+
+        session_start_data = {
+            "session_id": session_id,
+            "working_directory": working_dir,
+            "git_branch": git_branch,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "hook_event_name": "SessionStart",
+        }
+
+        # Auto-inject pending autotodos if enabled
+        try:
+            from pathlib import Path
+
+            from claude_mpm.cli.commands.autotodos import get_pending_todos
+            from claude_mpm.core.config import Config
+
+            config = Config()
+            auto_inject_enabled = config.get("autotodos.auto_inject_on_startup", True)
+            max_todos = config.get("autotodos.max_todos_per_session", 10)
+
+            if auto_inject_enabled:
+                # Pass working directory from event to avoid Path.cwd() issues
+                working_dir_param = None
+                if working_dir:
+                    working_dir_param = Path(working_dir)
+
+                pending_todos = get_pending_todos(
+                    max_todos=max_todos, working_dir=working_dir_param
+                )
+                if pending_todos:
+                    session_start_data["pending_autotodos"] = pending_todos
+                    session_start_data["autotodos_count"] = len(pending_todos)
+                    _log(f"  - Auto-injected {len(pending_todos)} pending autotodos")
+        except Exception as e:  # nosec B110
+            # Auto-injection is optional - continue if it fails
+            _log(f"  - Failed to auto-inject autotodos: {e}")
+
+        # Debug logging
+        _log(f"Hook handler: Processing SessionStart - session: '{session_id}'")
+
+        # Emit normalized event
+        self.hook_handler._emit_socketio_event("", "session_start", session_start_data)
+
+    def handle_subagent_start_fast(self, event):
+        """Handle SubagentStart events with proper agent type extraction.
+
+        WHY separate from SessionStart:
+        - SubagentStart contains agent-specific information
+        - Frontend needs agent_type to create distinct agent nodes
+        - Multiple engineers should show as separate nodes in hierarchy
+        - Research agents must appear in the agent hierarchy
+
+        Unlike SessionStart, SubagentStart events contain agent-specific
+        information that must be preserved and emitted to the dashboard.
+        """
+        session_id = event.get("session_id", "")
+
+        # Extract agent type from event - Claude provides this in SubagentStart
+        # Try multiple possible field names for compatibility
+        agent_type = event.get("agent_type") or event.get("subagent_type") or "unknown"
+
+        # Generate unique agent ID combining type and session
+        agent_id = event.get("agent_id", f"{agent_type}_{session_id[:8]}")
+
+        # Get working directory and git branch
+        working_dir = event.get("cwd", "")
+        git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+
+        # Build subagent start data with all required fields
+        subagent_start_data = {
+            "session_id": session_id,
+            "agent_type": agent_type,
+            "agent_id": agent_id,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "hook_event_name": "SubagentStart",  # Preserve correct hook name
+            "working_directory": working_dir,
+            "git_branch": git_branch,
+        }
+
+        # Debug logging
+        if DEBUG:
+            _log(
+                f"Hook handler: SubagentStart - agent_type='{agent_type}', agent_id='{agent_id}', session_id='{session_id[:16]}...'"
+            )
+
+        # Emit to /hook namespace as subagent_start (NOT session_start!)
+        self.hook_handler._emit_socketio_event(
+            "", "subagent_start", subagent_start_data
+        )
+
+    def _scan_for_delegation_patterns(self, event):
+        """Scan assistant response for delegation anti-patterns.
+
+        WHY this is needed:
+        - Detect when PM asks user to do something manually instead of delegating
+        - Flag PM behavior violations for immediate correction
+        - Enforce delegation principle in PM workflow
+        - Help PM recognize delegation opportunities
+
+        This method scans the assistant's response text for patterns like:
+        - "Make sure .env.local is in your .gitignore"
+        - "You'll need to run npm install"
+        - "Please run the tests manually"
+
+        When patterns are detected, PM violations are logged as errors/warnings
+        that should be corrected immediately, NOT as todos to delegate.
+
+        DESIGN DECISION: pm.violation vs autotodo.delegation
+        - Delegation patterns = PM doing something WRONG → pm.violation (error)
+        - Script failures = Something BROKEN → autotodo.error (todo)
+        """
+        # Only scan if delegation detector is available
+        try:
+            from claude_mpm.services.delegation_detector import get_delegation_detector
+            from claude_mpm.services.event_log import get_event_log
+        except ImportError:
+            if DEBUG:
+                _log("Delegation detector or event log not available")
+            return
+
+        response_text = event.get("response", "")
+        if not response_text:
+            return
+
+        # Get the delegation detector
+        detector = get_delegation_detector()
+
+        # Detect delegation patterns
+        detections = detector.detect_user_delegation(response_text)
+
+        if not detections:
+            return  # No patterns detected
+
+        # Get event log for violation recording
+        event_log = get_event_log()
+
+        # Create PM violation events (NOT autotodos)
+        for detection in detections:
+            # Create event log entry as pm.violation
+            event_log.append_event(
+                event_type="pm.violation",
+                payload={
+                    "violation_type": "delegation_anti_pattern",
+                    "pattern_type": detection["pattern_type"],
+                    "original_text": detection["original_text"],
+                    "suggested_action": detection["suggested_todo"],
+                    "action": detection["action"],
+                    "session_id": event.get("session_id", ""),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "severity": "warning",  # Not critical, but should be fixed
+                    "message": f"PM asked user to do something manually: {detection['original_text'][:80]}...",
+                },
+                status="pending",
+            )
+
+            if DEBUG:
+                _log(f"⚠️  PM violation detected: {detection['original_text'][:60]}...")