claude-mpm 5.6.3__py3-none-any.whl → 5.6.16__py3-none-any.whl

claude_mpm/hooks/claude_hooks/auto_pause_handler.py

@@ -22,7 +22,7 @@ USAGE:
         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)
+            _log(f"\n⚠️  {warning}")
 
     # Record actions during pause mode
     if auto_pause.is_pause_active():
@@ -34,7 +34,6 @@ USAGE:
 """
 
 import os
-import sys
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -45,6 +44,15 @@ from claude_mpm.services.infrastructure.context_usage_tracker import (
     ContextUsageTracker,
 )
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
 logger = get_logger(__name__)
 
 # Debug mode
@@ -100,11 +108,10 @@ class AutoPauseHandler:
             self._previous_threshold = current_state.threshold_reached
 
             if DEBUG:
-                print(
+                _log(
                     f"AutoPauseHandler initialized: "
                     f"{current_state.percentage_used:.1f}% context used, "
-                    f"threshold: {current_state.threshold_reached}",
-                    file=sys.stderr,
+                    f"threshold: {current_state.threshold_reached}"
                 )
         except Exception as e:
             logger.error(f"Failed to initialize AutoPauseHandler: {e}")
@@ -169,10 +176,9 @@ class AutoPauseHandler:
                     self._previous_threshold = current_threshold
 
                     if DEBUG:
-                        print(
+                        _log(
                             f"Context threshold crossed: {current_threshold} "
-                            f"({state.percentage_used:.1f}%)",
-                            file=sys.stderr,
+                            f"({state.percentage_used:.1f}%)"
                         )
 
                     # Trigger auto-pause if threshold reached
@@ -184,7 +190,7 @@ class AutoPauseHandler:
         except Exception as e:
             logger.error(f"Failed to update usage: {e}")
             if DEBUG:
-                print(f"❌ Usage update failed: {e}", file=sys.stderr)
+                _log(f"❌ Usage update failed: {e}")
             # Don't propagate error - auto-pause is optional
             return None
 
@@ -220,12 +226,12 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(f"Recorded tool call during pause: {tool_name}", file=sys.stderr)
+                _log(f"Recorded tool call during pause: {tool_name}")
 
         except Exception as e:
             logger.error(f"Failed to record tool call: {e}")
             if DEBUG:
-                print(f"❌ Failed to record tool call: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record tool call: {e}")
 
     def on_assistant_response(self, response_summary: str) -> None:
         """Record an assistant response if auto-pause is active.
@@ -257,15 +263,14 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
-                    f"Recorded assistant response during pause (length: {len(summary)})",
-                    file=sys.stderr,
+                _log(
+                    f"Recorded assistant response during pause (length: {len(summary)})"
                 )
 
         except Exception as e:
             logger.error(f"Failed to record assistant response: {e}")
             if DEBUG:
-                print(f"❌ Failed to record assistant response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record assistant response: {e}")
 
     def on_user_message(self, message_summary: str) -> None:
         """Record a user message if auto-pause is active.
@@ -297,15 +302,12 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
-                    f"Recorded user message during pause (length: {len(summary)})",
-                    file=sys.stderr,
-                )
+                _log(f"Recorded user message during pause (length: {len(summary)})")
 
         except Exception as e:
             logger.error(f"Failed to record user message: {e}")
             if DEBUG:
-                print(f"❌ Failed to record user message: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record user message: {e}")
 
     def on_session_end(self) -> Optional[Path]:
         """Called when session ends. Finalizes any active pause.
@@ -318,7 +320,7 @@ class AutoPauseHandler:
         """
         if not self.is_pause_active():
             if DEBUG:
-                print("No active pause to finalize", file=sys.stderr)
+                _log("No active pause to finalize")
             return None
 
         try:
@@ -326,14 +328,14 @@ class AutoPauseHandler:
             session_path = self.pause_manager.finalize_pause(create_full_snapshot=True)
 
             if session_path and DEBUG:
-                print(f"✅ Session finalized: {session_path.name}", file=sys.stderr)
+                _log(f"✅ Session finalized: {session_path.name}")
 
             return session_path
 
         except Exception as e:
             logger.error(f"Failed to finalize pause session: {e}")
             if DEBUG:
-                print(f"❌ Failed to finalize pause: {e}", file=sys.stderr)
+                _log(f"❌ Failed to finalize pause: {e}")
             raise
 
     def is_pause_active(self) -> bool:
@@ -417,9 +419,7 @@ class AutoPauseHandler:
             # Check if pause is already active
             if self.is_pause_active():
                 if DEBUG:
-                    print(
-                        "Auto-pause already active, skipping trigger", file=sys.stderr
-                    )
+                    _log("Auto-pause already active, skipping trigger")
                 return
 
             # Start incremental pause
@@ -429,16 +429,15 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
+                _log(
                     f"✅ Auto-pause triggered: {session_id} "
-                    f"({state.percentage_used:.1f}% context used)",
-                    file=sys.stderr,
+                    f"({state.percentage_used:.1f}% context used)"
                 )
 
         except Exception as e:
             logger.error(f"Failed to trigger auto-pause: {e}")
             if DEBUG:
-                print(f"❌ Failed to trigger auto-pause: {e}", file=sys.stderr)
+                _log(f"❌ Failed to trigger auto-pause: {e}")
             # Don't propagate - auto-pause is optional
 
     def _summarize_dict(

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -8,12 +8,20 @@ Claude Code hook events.
 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
 
+# 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)
@@ -34,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:
@@ -111,14 +119,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 +149,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", {})
@@ -180,9 +193,8 @@ class EventHandlers:
 
             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 +208,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 +224,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 +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
@@ -272,24 +280,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
@@ -359,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."""
@@ -450,9 +451,8 @@ class EventHandlers:
 
         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 = {
@@ -605,16 +605,25 @@ class EventHandlers:
                         _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:
@@ -656,24 +665,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."""
@@ -735,10 +735,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 (
@@ -751,10 +748,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:
@@ -823,9 +817,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
@@ -836,16 +829,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.
@@ -872,7 +862,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", "")
@@ -921,9 +911,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
@@ -939,7 +928,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(
@@ -990,22 +979,13 @@ class EventHandlers:
                 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,
-                        )
+                    _log(f"  - Auto-injected {len(pending_todos)} pending autotodos")
         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)
+            _log(f"  - Failed to auto-inject autotodos: {e}")
 
         # 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)
@@ -1048,10 +1028,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!)
@@ -1086,7 +1064,7 @@ class EventHandlers:
             from claude_mpm.services.event_log import get_event_log
         except ImportError:
             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", "")
@@ -1125,7 +1103,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]}...")

claude_mpm/hooks/claude_hooks/installer.py

@@ -537,6 +537,44 @@ main "$@"
         except Exception as e:
             self.logger.warning(f"Could not clean up old settings file: {e}")
 
+    def _fix_status_line(self, settings: Dict) -> None:
+        """Fix statusLine command to handle both output style schema formats.
+
+        The statusLine command receives input in different formats:
+        - Newer format: {"activeOutputStyle": "Claude MPM", ...}
+        - Older format: {"output_style": {"name": "Claude MPM"}, ...}
+
+        This method ensures the jq expression checks both locations.
+
+        Args:
+            settings: The settings dictionary to update
+        """
+        if "statusLine" not in settings:
+            return
+
+        status_line = settings.get("statusLine", {})
+        if "command" not in status_line:
+            return
+
+        command = status_line["command"]
+
+        # Pattern to match: '.output_style.name // "default"'
+        # We need to update it to: '.output_style.name // .activeOutputStyle // "default"'
+        old_pattern = r'\.output_style\.name\s*//\s*"default"'
+        new_pattern = '.output_style.name // .activeOutputStyle // "default"'
+
+        # Check if the command needs updating
+        if re.search(old_pattern, command) and ".activeOutputStyle" not in command:
+            updated_command = re.sub(old_pattern, new_pattern, command)
+            settings["statusLine"]["command"] = updated_command
+            self.logger.info(
+                "Fixed statusLine command to handle both output style schemas"
+            )
+        else:
+            self.logger.debug(
+                "StatusLine command already supports both schemas or not present"
+            )
+
     def _update_claude_settings(self, hook_script_path: Path) -> None:
         """Update Claude settings to use the installed hook."""
         self.logger.info("Updating Claude settings...")
@@ -598,6 +636,9 @@ main "$@"
             }
         ]
 
+        # Fix statusLine command to handle both output style schemas
+        self._fix_status_line(settings)
+
         # Write settings to settings.json
         with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)