claude-mpm 5.1.9__py3-none-any.whl → 5.4.22__py3-none-any.whl

claude_mpm/hooks/claude_hooks/correlation_manager.py

@@ -0,0 +1,60 @@
+"""Cross-process correlation storage using .claude-mpm directory."""
+
+import json
+import time
+from pathlib import Path
+
+
+def get_correlation_dir() -> Path:
+    """Get correlation directory in project's .claude-mpm folder."""
+    # Use CWD's .claude-mpm directory (where hooks run from)
+    cwd = Path.cwd()
+    return cwd / ".claude-mpm" / "correlations"
+
+
+TTL_SECONDS = 3600  # 1 hour
+
+
+class CorrelationManager:
+    """Manages correlation IDs across separate hook processes."""
+
+    @staticmethod
+    def store(session_id: str, tool_call_id: str, tool_name: str) -> None:
+        """Store correlation data for later retrieval by post_tool."""
+        correlation_dir = get_correlation_dir()
+        correlation_dir.mkdir(parents=True, exist_ok=True)
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        data = {
+            "tool_call_id": tool_call_id,
+            "tool_name": tool_name,
+            "timestamp": time.time(),
+        }
+        filepath.write_text(json.dumps(data))
+
+    @staticmethod
+    def retrieve(session_id: str) -> str | None:
+        """Retrieve and delete correlation data from temp file."""
+        correlation_dir = get_correlation_dir()
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        if not filepath.exists():
+            return None
+        try:
+            data = json.loads(filepath.read_text())
+            filepath.unlink()  # Delete after reading
+            return data.get("tool_call_id")
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @staticmethod
+    def cleanup_old() -> None:
+        """Remove correlation files older than TTL."""
+        correlation_dir = get_correlation_dir()
+        if not correlation_dir.exists():
+            return
+        now = time.time()
+        for filepath in correlation_dir.glob("correlation_*.json"):
+            try:
+                if now - filepath.stat().st_mtime > TTL_SECONDS:
+                    filepath.unlink()
+            except OSError:
+                pass

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -9,6 +9,7 @@ import os
 import re
 import subprocess
 import sys
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
@@ -94,22 +95,29 @@ 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,
-                }
-                if DEBUG:
-                    print(
-                        f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
-                        file=sys.stderr,
-                    )
+        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:
+                        print(
+                            f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
+                            file=sys.stderr,
+                        )
+        except Exception:
+            # Response tracking is optional - silently continue if it fails
+            pass
 
         # Emit normalized event (namespace no longer needed with normalized events)
         self.hook_handler._emit_socketio_event("", "user_prompt", prompt_data)
@@ -134,6 +142,9 @@ class EventHandlers:
         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 +155,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,15 +164,27 @@ 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:
+                print(
+                    f"  - Generated tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
+                    file=sys.stderr,
+                )
+
         # 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)
@@ -226,8 +251,11 @@ class EventHandlers:
                     f"  - Request data keys: {list(request_data.keys())}",
                     file=sys.stderr,
                 )
+                delegation_requests = getattr(
+                    self.hook_handler, "delegation_requests", {}
+                )
                 print(
-                    f"  - delegation_requests size: {len(self.hook_handler.delegation_requests)}",
+                    f"  - delegation_requests size: {len(delegation_requests)}",
                     file=sys.stderr,
                 )
 
@@ -239,9 +267,13 @@ class EventHandlers:
                 )
 
         # 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:
+            # Memory hooks are optional
+            pass
 
         # Emit a subagent_start event for better tracking
         subagent_start_data = {
@@ -375,6 +407,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 +419,16 @@ 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:
+            print(
+                f"  - Retrieved tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
+                file=sys.stderr,
+            )
+
         post_tool_data = {
             "tool_name": tool_name,
             "exit_code": exit_code,
@@ -399,7 +442,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 +455,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:
+                # 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:
+                # Response tracking is optional
+                pass
 
         self.hook_handler._emit_socketio_event("", "post_tool", post_tool_data)
 
@@ -486,9 +551,14 @@ class EventHandlers:
             self._log_stop_event_debug(event, session_id, metadata)
 
         # 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:
+            # Response tracking is optional
+            pass
 
         # Emit stop event to Socket.IO
         self._emit_stop_event(event, session_id, metadata)
@@ -511,15 +581,27 @@ 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: {tracking_enabled}",
+                file=sys.stderr,
+            )
+            print(
+                f"  - response_tracker exists: {tracker_exists}",
+                file=sys.stderr,
+            )
+        except Exception:
+            # If debug logging fails, just skip it
+            pass
 
-        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,
@@ -567,15 +649,22 @@ 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)
 
             # If exact match fails, try partial matching
             if not request_info and session_id:
@@ -585,7 +674,7 @@ class EventHandlers:
                         file=sys.stderr,
                     )
                 # 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])
@@ -600,17 +689,13 @@ class EventHandlers:
                                 f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
                                 file=sys.stderr,
                             )
-                        request_info = self.hook_handler.delegation_requests.get(
-                            stored_sid
-                        )
+                        request_info = delegation_requests.get(stored_sid)
                         # 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,23 +743,31 @@ 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:
+                        print(
+                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
+                            file=sys.stderr,
+                        )
+
                 # Clean up the request data
-                if session_id in self.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(
@@ -698,9 +791,14 @@ class EventHandlers:
         - Essential for comprehensive monitoring of Claude interactions
         """
         # 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:
+            # Response tracking is optional
+            pass
 
         # Get working directory and git branch
         working_dir = event.get("cwd", "")
@@ -730,16 +828,21 @@ 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
@@ -753,3 +856,33 @@ class EventHandlers:
         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
+        """
+        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",
+        }
+
+        # Debug logging
+        if DEBUG:
+            print(
+                f"Hook handler: Processing SessionStart - session: '{session_id}'",
+                file=sys.stderr,
+            )
+
+        # Emit normalized event
+        self.hook_handler._emit_socketio_event("", "session_start", session_start_data)

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -304,6 +304,10 @@ class ClaudeHookHandler:
             # Perform periodic cleanup if needed
             if self.state_manager.increment_events_processed():
                 self.state_manager.cleanup_old_entries()
+                # Also cleanup old correlation files
+                from .correlation_manager import CorrelationManager
+
+                CorrelationManager.cleanup_old()
                 if DEBUG:
                     print(
                         f"🧹 Performed cleanup after {self.state_manager.events_processed} events",
@@ -413,6 +417,8 @@ class ClaudeHookHandler:
             "Notification": self.event_handlers.handle_notification_fast,
             "Stop": self.event_handlers.handle_stop_fast,
             "SubagentStop": self.event_handlers.handle_subagent_stop_fast,
+            "SubagentStart": self.event_handlers.handle_session_start_fast,
+            "SessionStart": self.event_handlers.handle_session_start_fast,
             "AssistantResponse": self.event_handlers.handle_assistant_response,
         }
 

claude_mpm/hooks/claude_hooks/installer.py

@@ -202,8 +202,9 @@ main "$@"
         self.hooks_dir = self.claude_dir / "hooks"  # Kept for backward compatibility
         # Use settings.json for hooks (Claude Code reads from this file)
         self.settings_file = self.claude_dir / "settings.json"
-        # Keep reference to old file for migration
-        self.old_settings_file = self.claude_dir / "settings.json"
+        # There is no legacy settings file - this was a bug where both pointed to same file
+        # Setting to None to disable cleanup that was deleting freshly installed hooks
+        self.old_settings_file = None
         self._claude_version: Optional[str] = None
         self._hook_script_path: Optional[Path] = None
 
@@ -462,7 +463,9 @@ main "$@"
 
     def _cleanup_old_settings(self) -> None:
         """Remove hooks from old settings.json file if present."""
-        if not self.old_settings_file.exists():
+        # No-op: old_settings_file was pointing to same file as settings_file (bug)
+        # This was causing freshly installed hooks to be immediately deleted
+        if self.old_settings_file is None or not self.old_settings_file.exists():
             return
 
         try:
@@ -518,15 +521,31 @@ main "$@"
                 }
             ]
 
-        # Non-tool events don't need a matcher
-        non_tool_events = ["UserPromptSubmit", "Stop", "SubagentStop", "SubagentStart"]
-        for event_type in non_tool_events:
+        # Simple events (no subtypes, no matcher needed)
+        simple_events = ["Stop", "SubagentStop", "SubagentStart"]
+        for event_type in simple_events:
             settings["hooks"][event_type] = [
                 {
                     "hooks": [hook_command],
                 }
             ]
 
+        # SessionStart needs matcher for subtypes (startup, resume)
+        settings["hooks"]["SessionStart"] = [
+            {
+                "matcher": "*",  # Match all SessionStart subtypes
+                "hooks": [hook_command],
+            }
+        ]
+
+        # UserPromptSubmit needs matcher for potential subtypes
+        settings["hooks"]["UserPromptSubmit"] = [
+            {
+                "matcher": "*",
+                "hooks": [hook_command],
+            }
+        ]
+
         # Write settings to settings.json
         with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)
@@ -650,9 +669,13 @@ main "$@"
                 old_script.unlink()
                 self.logger.info(f"Removed old deployed script: {old_script}")
 
-            # Remove from Claude settings (both old and new locations)
-            for settings_path in [self.settings_file, self.old_settings_file]:
-                if settings_path.exists():
+            # Remove from Claude settings
+            settings_paths = [self.settings_file]
+            if self.old_settings_file is not None:
+                settings_paths.append(self.old_settings_file)
+
+            for settings_path in settings_paths:
+                if settings_path and settings_path.exists():
                     with settings_path.open() as f:
                         settings = json.load(f)
 
@@ -763,7 +786,7 @@ main "$@"
                 pass
 
         # Also check old settings file
-        if self.old_settings_file.exists():
+        if self.old_settings_file is not None and self.old_settings_file.exists():
             try:
                 with self.old_settings_file.open() as f:
                     old_settings = json.load(f)

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -6,18 +6,35 @@ including pre and post delegation hooks.
 """
 
 import logging
+import os
 import sys
 
-# Reconfigure logging to INFO level BEFORE kuzu-memory imports
+# Install-type-aware logging configuration BEFORE kuzu-memory imports
 # This overrides kuzu-memory's WARNING-level basicConfig (fixes 1M-445)
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    force=True,  # Python 3.8+ - reconfigures root logger
-    stream=sys.stderr,
-)
-
-import os
+# but respects production install silence
+try:
+    from claude_mpm.core.unified_paths import DeploymentContext, PathContext
+
+    context = PathContext.detect_deployment_context()
+
+    # Only configure verbose logging for development/editable installs
+    # Production installs remain silent by default
+    if context in (DeploymentContext.DEVELOPMENT, DeploymentContext.EDITABLE_INSTALL):
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            force=True,  # Python 3.8+ - reconfigures root logger
+            stream=sys.stderr,
+        )
+except ImportError:
+    # Fallback: if unified_paths not available, configure logging
+    # This maintains backward compatibility
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        force=True,
+        stream=sys.stderr,
+    )
 from datetime import datetime, timezone
 from typing import Optional