claude-mpm 5.6.1__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -3,16 +3,30 @@
 
 This module provides individual event handlers for different types of
 Claude Code hook events.
+
+Supports Dependency Injection:
+- Optional services can be passed via constructor
+- Lazy loading fallback for services not provided
+- Eliminates runtime imports inside methods
 """
 
+import asyncio
 import os
 import re
 import subprocess  # nosec B404 - subprocess used for safe claude CLI version checking only
-import sys
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
+from typing import Any, 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:
@@ -34,8 +48,15 @@ except ImportError:
         extract_tool_results,
     )
 
-# Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Import correlation manager with fallback for direct execution
+# WHY at top level: Runtime relative imports fail with "no known parent package" error
+try:
+    from .correlation_manager import CorrelationManager
+except ImportError:
+    from correlation_manager import CorrelationManager
+
+# 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:
@@ -46,13 +67,152 @@ except ImportError:
         QUICK_TIMEOUT = 2.0
 
 
+# ============================================================================
+# Optional Dependencies - loaded once at module level for DI
+# ============================================================================
+
+# Log manager (for agent prompt logging)
+_log_manager: Optional[Any] = None
+_log_manager_loaded = False
+
+
+def _get_log_manager() -> Optional[Any]:
+    """Get log manager with lazy loading."""
+    global _log_manager, _log_manager_loaded
+    if not _log_manager_loaded:
+        try:
+            from claude_mpm.core.log_manager import get_log_manager
+
+            _log_manager = get_log_manager()
+        except ImportError:
+            _log_manager = None
+        _log_manager_loaded = True
+    return _log_manager
+
+
+# Config service (for autotodos configuration)
+_config: Optional[Any] = None
+_config_loaded = False
+
+
+def _get_config() -> Optional[Any]:
+    """Get Config with lazy loading."""
+    global _config, _config_loaded
+    if not _config_loaded:
+        try:
+            from claude_mpm.core.config import Config
+
+            _config = Config()
+        except ImportError:
+            _config = None
+        _config_loaded = True
+    return _config
+
+
+# Delegation detector (for anti-pattern detection)
+_delegation_detector: Optional[Any] = None
+_delegation_detector_loaded = False
+
+
+def _get_delegation_detector_service() -> Optional[Any]:
+    """Get delegation detector with lazy loading."""
+    global _delegation_detector, _delegation_detector_loaded
+    if not _delegation_detector_loaded:
+        try:
+            from claude_mpm.services.delegation_detector import get_delegation_detector
+
+            _delegation_detector = get_delegation_detector()
+        except ImportError:
+            _delegation_detector = None
+        _delegation_detector_loaded = True
+    return _delegation_detector
+
+
+# Event log (for PM violation logging)
+_event_log: Optional[Any] = None
+_event_log_loaded = False
+
+
+def _get_event_log_service() -> Optional[Any]:
+    """Get event log with lazy loading."""
+    global _event_log, _event_log_loaded
+    if not _event_log_loaded:
+        try:
+            from claude_mpm.services.event_log import get_event_log
+
+            _event_log = get_event_log()
+        except ImportError:
+            _event_log = None
+        _event_log_loaded = True
+    return _event_log
+
+
 class EventHandlers:
-    """Collection of event handlers for different Claude Code hook events."""
+    """Collection of event handlers for different Claude Code hook events.
+
+    Supports dependency injection for optional services:
+    - log_manager: For agent prompt logging
+    - config: For autotodos configuration
+    - delegation_detector: For anti-pattern detection
+    - event_log: For PM violation logging
+
+    If services are not provided, they are loaded lazily on first use.
+    """
 
-    def __init__(self, hook_handler):
-        """Initialize with reference to the main hook handler."""
+    def __init__(
+        self,
+        hook_handler,
+        *,
+        log_manager: Optional[Any] = None,
+        config: Optional[Any] = None,
+        delegation_detector: Optional[Any] = None,
+        event_log: Optional[Any] = None,
+    ):
+        """Initialize with reference to the main hook handler and optional services.
+
+        Args:
+            hook_handler: The main ClaudeHookHandler instance
+            log_manager: Optional LogManager for agent prompt logging
+            config: Optional Config for autotodos configuration
+            delegation_detector: Optional DelegationDetector for anti-pattern detection
+            event_log: Optional EventLog for PM violation logging
+        """
         self.hook_handler = hook_handler
 
+        # Store injected services (None means use lazy loading)
+        self._log_manager = log_manager
+        self._config = config
+        self._delegation_detector = delegation_detector
+        self._event_log = event_log
+
+    @property
+    def log_manager(self) -> Optional[Any]:
+        """Get log manager (injected or lazy loaded)."""
+        if self._log_manager is not None:
+            return self._log_manager
+        return _get_log_manager()
+
+    @property
+    def config(self) -> Optional[Any]:
+        """Get config (injected or lazy loaded)."""
+        if self._config is not None:
+            return self._config
+        return _get_config()
+
+    @property
+    def delegation_detector(self) -> Optional[Any]:
+        """Get delegation detector (injected or lazy loaded)."""
+        if self._delegation_detector is not None:
+            return self._delegation_detector
+        return _get_delegation_detector_service()
+
+    @property
+    def event_log(self) -> Optional[Any]:
+        """Get event log (injected or lazy loaded)."""
+        if self._event_log is not None:
+            return self._event_log
+        return _get_event_log_service()
+
     def handle_user_prompt_fast(self, event):
         """Handle user prompt with comprehensive data capture.
 
@@ -111,14 +271,22 @@ class EventHandlers:
                         "working_directory": working_dir,
                     }
                     if DEBUG:
-                        print(
-                            f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
-                            file=sys.stderr,
+                        _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:
+                    _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)
 
@@ -133,11 +301,8 @@ 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", {})
@@ -176,13 +341,10 @@ class EventHandlers:
 
         # 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:
-                print(
-                    f"  - Generated tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
-                    file=sys.stderr,
+                _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
@@ -196,7 +358,7 @@ class EventHandlers:
                 auto_pause.on_tool_call(tool_name, tool_input)
             except Exception as e:
                 if DEBUG:
-                    print(f"Auto-pause tool recording error: {e}", file=sys.stderr)
+                    _log(f"Auto-pause tool recording error: {e}")
 
         self.hook_handler._emit_socketio_event("", "pre_tool", pre_tool_data)
 
@@ -212,9 +374,8 @@ class EventHandlers:
             }
             self.hook_handler._emit_socketio_event("", "todo_updated", todo_data)
             if DEBUG:
-                print(
-                    f"  - Emitted todo_updated event with {len(tool_params['todos'])} todos for session {session_id[:8]}...",
-                    file=sys.stderr,
+                _log(
+                    f"  - Emitted todo_updated event with {len(tool_params['todos'])} todos for session {session_id[:8]}..."
                 )
 
     def _handle_task_delegation(
@@ -255,12 +416,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
@@ -272,24 +430,17 @@ 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,
-                )
+                _log("  - Delegation tracked successfully")
+                _log(f"  - Request data keys: {list(request_data.keys())}")
                 delegation_requests = getattr(
                     self.hook_handler, "delegation_requests", {}
                 )
-                print(
-                    f"  - delegation_requests size: {len(delegation_requests)}",
-                    file=sys.stderr,
-                )
+                _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
@@ -316,53 +467,50 @@ class EventHandlers:
         )
 
         # Log agent prompt if LogManager is available
-        try:
-            from claude_mpm.core.log_manager import get_log_manager
-
-            log_manager = get_log_manager()
-
-            # Prepare prompt content
-            prompt_content = tool_input.get("prompt", "")
-            if not prompt_content:
-                prompt_content = tool_input.get("description", "")
-
-            if prompt_content:
-                import asyncio
-
-                # Prepare metadata
-                metadata = {
-                    "agent_type": agent_type,
-                    "agent_id": f"{agent_type}_{session_id}",
-                    "session_id": session_id,
-                    "delegation_context": {
-                        "description": tool_input.get("description", ""),
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                }
+        # Uses injected log_manager or lazy-loaded module-level instance
+        log_manager = self.log_manager
+        if log_manager is not None:
+            try:
+                # Prepare prompt content
+                prompt_content = tool_input.get("prompt", "")
+                if not prompt_content:
+                    prompt_content = tool_input.get("description", "")
+
+                if prompt_content:
+                    # Prepare metadata
+                    metadata = {
+                        "agent_type": agent_type,
+                        "agent_id": f"{agent_type}_{session_id}",
+                        "session_id": session_id,
+                        "delegation_context": {
+                            "description": tool_input.get("description", ""),
+                            "timestamp": datetime.now(timezone.utc).isoformat(),
+                        },
+                    }
 
-                # Log the agent prompt asynchronously
-                try:
-                    loop = asyncio.get_running_loop()
-                    _task = asyncio.create_task(
-                        log_manager.log_prompt(
-                            f"agent_{agent_type}", prompt_content, metadata
-                        )
-                    )  # Fire-and-forget logging (ephemeral hook process)
-                except RuntimeError:
-                    # No running loop, create one
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                    loop.run_until_complete(
-                        log_manager.log_prompt(
-                            f"agent_{agent_type}", prompt_content, metadata
+                    # Log the agent prompt asynchronously
+                    try:
+                        loop = asyncio.get_running_loop()
+                        _task = asyncio.create_task(
+                            log_manager.log_prompt(
+                                f"agent_{agent_type}", prompt_content, metadata
+                            )
+                        )  # Fire-and-forget logging (ephemeral hook process)
+                    except RuntimeError:
+                        # No running loop, create one
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        loop.run_until_complete(
+                            log_manager.log_prompt(
+                                f"agent_{agent_type}", prompt_content, metadata
+                            )
                         )
-                    )
 
+                    if DEBUG:
+                        _log(f"  - Agent prompt logged for {agent_type}")
+            except Exception as e:
                 if DEBUG:
-                    print(f"  - Agent prompt logged for {agent_type}", file=sys.stderr)
-        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."""
@@ -446,13 +594,10 @@ class EventHandlers:
         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:
-            print(
-                f"  - Retrieved tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
-                file=sys.stderr,
+            _log(
+                f"  - Retrieved tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}..."
             )
 
         post_tool_data = {
@@ -598,19 +743,30 @@ class EventHandlers:
                     threshold_crossed = auto_pause.on_usage_update(metadata["usage"])
                     if threshold_crossed:
                         warning = auto_pause.emit_threshold_warning(threshold_crossed)
-                        print(f"\n⚠️  {warning}", file=sys.stderr)
+                        # CRITICAL: Never write to stderr unconditionally - causes hook errors
+                        # Use _log() instead which only writes to file if DEBUG=true
+                        _log(f"⚠️  Auto-pause threshold crossed: {warning}")
 
                         if DEBUG:
-                            print(
-                                f"  - Auto-pause threshold crossed: {threshold_crossed}",
-                                file=sys.stderr,
+                            _log(
+                                f"  - Auto-pause threshold crossed: {threshold_crossed}"
                             )
                 except Exception as e:
                     if DEBUG:
-                        print(
-                            f"Auto-pause error in handle_stop_fast: {e}",
-                            file=sys.stderr,
-                        )
+                        _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
         try:
@@ -652,24 +808,15 @@ class EventHandlers:
                 getattr(rtm, "response_tracker", None) is not None if rtm else False
             )
 
-            print(
-                f"  - response_tracking_enabled: {tracking_enabled}",
-                file=sys.stderr,
-            )
-            print(
-                f"  - response_tracker exists: {tracker_exists}",
-                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
 
-        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"  - 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."""
@@ -731,10 +878,7 @@ class EventHandlers:
             # 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(delegation_requests.keys()):
                     if (
@@ -747,10 +891,7 @@ class EventHandlers:
                         )
                     ):
                         if DEBUG:
-                            print(
-                                f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
-                                file=sys.stderr,
-                            )
+                            _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:
@@ -819,9 +960,8 @@ class EventHandlers:
                     )
 
                     if file_path and DEBUG:
-                        print(
-                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
-                            file=sys.stderr,
+                        _log(
+                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}"
                         )
 
                 # Clean up the request data
@@ -832,16 +972,13 @@ class EventHandlers:
                     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.
@@ -868,7 +1005,7 @@ class EventHandlers:
             self._scan_for_delegation_patterns(event)
         except Exception as e:  # nosec B110
             if DEBUG:
-                print(f"Delegation scanning error: {e}", file=sys.stderr)
+                _log(f"Delegation scanning error: {e}")
 
         # Get working directory and git branch
         working_dir = event.get("cwd", "")
@@ -917,9 +1054,8 @@ class EventHandlers:
 
         # 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
@@ -935,7 +1071,7 @@ class EventHandlers:
                 auto_pause.on_assistant_response(summary)
             except Exception as e:
                 if DEBUG:
-                    print(f"Auto-pause response recording error: {e}", file=sys.stderr)
+                    _log(f"Auto-pause response recording error: {e}")
 
         # Emit normalized event
         self.hook_handler._emit_socketio_event(
@@ -949,7 +1085,9 @@ class EventHandlers:
         - 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
+
+        NOTE: This handler is intentionally lightweight - only event monitoring.
+        All initialization/deployment logic runs in MPM CLI startup, not here.
         """
         session_id = event.get("session_id", "")
         working_dir = event.get("cwd", "")
@@ -963,45 +1101,8 @@ class EventHandlers:
             "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)
-                    if DEBUG:
-                        print(
-                            f"  - Auto-injected {len(pending_todos)} pending autotodos",
-                            file=sys.stderr,
-                        )
-        except Exception as e:  # nosec B110
-            # Auto-injection is optional - continue if it fails
-            if DEBUG:
-                print(f"  - Failed to auto-inject autotodos: {e}", file=sys.stderr)
-
         # Debug logging
-        if DEBUG:
-            print(
-                f"Hook handler: Processing SessionStart - session: '{session_id}'",
-                file=sys.stderr,
-            )
+        _log(f"Hook handler: Processing SessionStart - session: '{session_id}'")
 
         # Emit normalized event
         self.hook_handler._emit_socketio_event("", "session_start", session_start_data)
@@ -1044,10 +1145,8 @@ class EventHandlers:
 
         # Debug logging
         if DEBUG:
-            print(
-                f"Hook handler: SubagentStart - agent_type='{agent_type}', "
-                f"agent_id='{agent_id}', session_id='{session_id[:16]}...'",
-                file=sys.stderr,
+            _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!)
@@ -1076,35 +1175,30 @@ class EventHandlers:
         - 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:
+        # Only scan if delegation detector and event log are available
+        # Uses injected services or lazy-loaded module-level instances
+        detector = self.delegation_detector
+        event_log_service = self.event_log
+
+        if detector is None or event_log_service is None:
             if DEBUG:
-                print("Delegation detector or event log not available", file=sys.stderr)
+                _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_log_service.append_event(
                 event_type="pm.violation",
                 payload={
                     "violation_type": "delegation_anti_pattern",
@@ -1121,7 +1215,4 @@ class EventHandlers:
             )
 
             if DEBUG:
-                print(
-                    f"⚠️  PM violation detected: {detection['original_text'][:60]}...",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️  PM violation detected: {detection['original_text'][:60]}...")