claude-mpm 5.4.3__py3-none-any.whl → 5.4.21__py3-none-any.whl

claude_mpm/core/framework/formatters/content_formatter.py

@@ -100,19 +100,9 @@ class ContentFormatter:
                 instructions += framework_content["actual_memories"]
                 instructions += "\n"
 
-            # Add agent memories if available
-            if framework_content.get("agent_memories"):
-                agent_memories = framework_content["agent_memories"]
-                if agent_memories:
-                    instructions += "\n\n## Agent Memories\n\n"
-                    instructions += "**The following are accumulated memories from specialized agents:**\n\n"
-
-                    for agent_name in sorted(agent_memories.keys()):
-                        memory_content = agent_memories[agent_name]
-                        if memory_content:
-                            instructions += f"### {agent_name.replace('_', ' ').title()} Agent Memory\n\n"
-                            instructions += memory_content
-                            instructions += "\n\n"
+            # NOTE: Agent memories are now injected at agent deployment time
+            # in agent_template_builder.py, not in PM instructions.
+            # This ensures each agent gets its own memory, not all memories embedded in PM.
 
             # Add dynamic agent capabilities section
             instructions += capabilities_section

claude_mpm/core/framework_loader.py

@@ -255,10 +255,12 @@ class FrameworkLoader:
         """Load actual memories using the MemoryManager service."""
         memories = self._memory_manager.load_memories()
 
+        # Only load PM memories (PM.md)
+        # Agent memories are loaded at deployment time in agent_template_builder.py
         if "actual_memories" in memories:
             content["actual_memories"] = memories["actual_memories"]
-        if "agent_memories" in memories:
-            content["agent_memories"] = memories["agent_memories"]
+        # NOTE: agent_memories are no longer loaded for PM instructions
+        # They are injected per-agent at deployment time
 
     # === Agent Discovery Methods ===
 

claude_mpm/core/logger.py

@@ -175,6 +175,19 @@ def setup_logging(
     Returns:
         Configured logger
     """
+    # Detect deployment context for install-type-aware defaults
+    if level == "INFO":  # Only override default, not explicit settings
+        from claude_mpm.core.unified_paths import DeploymentContext, PathContext
+
+        context = PathContext.detect_deployment_context()
+        if context in (
+            DeploymentContext.DEVELOPMENT,
+            DeploymentContext.EDITABLE_INSTALL,
+        ):
+            level = "INFO"  # Development: verbose logging
+        else:
+            level = "OFF"  # Production installs: silent by default
+
     logger = logging.getLogger(name)
 
     # Handle OFF level

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -95,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)
@@ -244,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,
                 )
 
@@ -257,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 = {
@@ -441,6 +455,11 @@ 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
@@ -451,14 +470,27 @@ class EventHandlers:
             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)
 
@@ -519,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)
@@ -544,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,
@@ -600,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:
@@ -618,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])
@@ -633,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:
@@ -691,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(
@@ -731,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", "")
@@ -763,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
@@ -786,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

@@ -417,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
 

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -18,8 +18,7 @@ DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
 # Response tracking integration
 # NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading
-# This prevents unnecessary import of base_agent_loader and other heavy dependencies
-# when hooks don't need response tracking
+# This prevents unnecessary import of heavy dependencies when hooks don't need response tracking
 RESPONSE_TRACKING_AVAILABLE = (
     True  # Assume available, will check on actual initialization
 )
@@ -51,7 +50,7 @@ class ResponseTrackingManager:
         response tracking without code changes.
 
         NOTE: ResponseTracker is imported lazily here to avoid loading
-        base_agent_loader and other heavy dependencies unless actually needed.
+        heavy dependencies unless actually needed.
         """
         try:
             # Lazy import of ResponseTracker to avoid unnecessary dependency loading

claude_mpm/hooks/memory_integration_hook.py

@@ -13,6 +13,7 @@ agent outputs because:
 """
 
 import re
+from datetime import datetime
 from typing import Dict, List
 
 from claude_mpm.core.config import Config
@@ -47,6 +48,16 @@ except ImportError as e:
     SOCKETIO_AVAILABLE = False
     get_socketio_server = None
 
+# Try to import event bus with fallback handling
+try:
+    from claude_mpm.services.event_bus.event_bus import EventBus
+
+    EVENT_BUS_AVAILABLE = True
+except ImportError as e:
+    logger.debug(f"EventBus not available: {e}")
+    EVENT_BUS_AVAILABLE = False
+    EventBus = None
+
 
 class MemoryPreDelegationHook(PreDelegationHook):
     """Inject agent memory into delegation context.
@@ -83,6 +94,16 @@ class MemoryPreDelegationHook(PreDelegationHook):
             logger.info("Memory manager not available - hook will be inactive")
             self.memory_manager = None
 
+        # Initialize event bus for observability
+        if EVENT_BUS_AVAILABLE and EventBus:
+            try:
+                self.event_bus = EventBus.get_instance()
+            except Exception as e:
+                logger.debug(f"Failed to get EventBus instance: {e}")
+                self.event_bus = None
+        else:
+            self.event_bus = None
+
     def execute(self, context: HookContext) -> HookResult:
         """Add agent memory to delegation context.
 
@@ -137,7 +158,31 @@ INSTRUCTIONS: Review your memory above before proceeding. Apply learned patterns
 
                     logger.info(f"Injected memory for agent '{agent_id}'")
 
-                    # Emit Socket.IO event for memory injected
+                    # Calculate memory size for observability
+                    memory_size = len(memory_content)
+
+                    # Emit event bus event for observability
+                    if self.event_bus:
+                        try:
+                            # Determine memory source (project or user level)
+                            # This is inferred from the memory manager's behavior
+                            memory_source = (
+                                "runtime"  # Runtime loading from memory manager
+                            )
+
+                            self.event_bus.publish(
+                                "agent.memory.loaded",
+                                {
+                                    "agent_id": agent_id,
+                                    "memory_source": memory_source,
+                                    "memory_size": memory_size,
+                                    "timestamp": datetime.now(datetime.UTC).isoformat(),
+                                },
+                            )
+                        except Exception as event_error:
+                            logger.debug(f"EventBus publish failed: {event_error}")
+
+                    # Emit Socket.IO event for memory injected (legacy compatibility)
                     try:
                         socketio_server = get_socketio_server()
                         # Calculate size of injected content