claude-mpm 4.0.20__py3-none-any.whl → 4.0.23__py3-none-any.whl

claude_mpm/core/config.py

@@ -8,6 +8,7 @@ and default values with proper validation and type conversion.
 import json
 import logging
 import os
+import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -37,16 +38,23 @@ class Config:
     _instance = None
     _initialized = False
     _success_logged = False  # Class-level flag to track if success message was already logged
+    _lock = threading.Lock()  # Thread safety for singleton initialization
 
     def __new__(cls, *args, **kwargs):
         """Implement singleton pattern to ensure single configuration instance.
         
         WHY: Configuration was being loaded 11 times during startup, once for each service.
         This singleton pattern ensures configuration is loaded only once and reused.
+        Thread-safe implementation prevents race conditions during concurrent initialization.
         """
         if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            logger.info("Creating new Config singleton instance")
+            with cls._lock:
+                # Double-check locking pattern for thread safety
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    logger.info("Creating new Config singleton instance")
+                else:
+                    logger.debug("Reusing existing Config singleton instance (concurrent init)")
         else:
             logger.debug("Reusing existing Config singleton instance")
         return cls._instance
@@ -66,6 +74,7 @@ class Config:
             env_prefix: Prefix for environment variables
         """
         # Skip initialization if already done (singleton pattern)
+        # Use thread-safe check to prevent concurrent initialization
         if Config._initialized:
             logger.debug("Config already initialized, skipping re-initialization")
             # If someone tries to load a different config file after initialization,
@@ -77,45 +86,52 @@ class Config:
                 )
             return
         
-        Config._initialized = True
-        logger.info("Initializing Config singleton for the first time")
-        
-        self._config: Dict[str, Any] = {}
-        self._env_prefix = env_prefix
-        self._config_mgr = ConfigurationManager(cache_enabled=True)
-
-        # Load base configuration
-        if config:
-            self._config.update(config)
-
-        # Track where configuration was loaded from
-        self._loaded_from = None
-        # Track the actual file we loaded from to prevent re-loading
-        self._actual_loaded_file = None
-
-        # Load from file if provided
-        if config_file:
-            self.load_file(config_file, is_initial_load=True)
-            self._loaded_from = str(config_file)
-        else:
-            # Try to load from standard location: .claude-mpm/configuration.yaml
-            default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
-            if default_config.exists():
-                self.load_file(default_config, is_initial_load=True)
-                self._loaded_from = str(default_config)
+        # Thread-safe initialization - acquire lock for ENTIRE initialization process
+        with Config._lock:
+            # Double-check pattern - check again inside the lock
+            if Config._initialized:
+                logger.debug("Config already initialized (concurrent), skipping re-initialization")
+                return
+            
+            Config._initialized = True
+            logger.info("Initializing Config singleton for the first time")
+            
+            # Initialize instance variables inside the lock to ensure thread safety
+            self._config: Dict[str, Any] = {}
+            self._env_prefix = env_prefix
+            self._config_mgr = ConfigurationManager(cache_enabled=True)
+
+            # Load base configuration
+            if config:
+                self._config.update(config)
+
+            # Track where configuration was loaded from
+            self._loaded_from = None
+            # Track the actual file we loaded from to prevent re-loading
+            self._actual_loaded_file = None
+
+            # Load from file if provided
+            # Note: Only ONE config file should be loaded, and success message shown only once
+            if config_file:
+                self.load_file(config_file, is_initial_load=True)
+                self._loaded_from = str(config_file)
             else:
-                # Also try .yml extension
-                alt_config = Path.cwd() / ".claude-mpm" / "configuration.yml"
-                if alt_config.exists():
+                # Try to load from standard location: .claude-mpm/configuration.yaml
+                default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+                if default_config.exists():
+                    self.load_file(default_config, is_initial_load=True)
+                    self._loaded_from = str(default_config)
+                elif (alt_config := Path.cwd() / ".claude-mpm" / "configuration.yml").exists():
+                    # Also try .yml extension (using walrus operator for cleaner code)
                     self.load_file(alt_config, is_initial_load=True)
                     self._loaded_from = str(alt_config)
 
-        # Load from environment variables (new and legacy prefixes)
-        self._load_env_vars()
-        self._load_legacy_env_vars()
+            # Load from environment variables (new and legacy prefixes)
+            self._load_env_vars()
+            self._load_legacy_env_vars()
 
-        # Apply defaults
-        self._apply_defaults()
+            # Apply defaults
+            self._apply_defaults()
 
     def load_file(self, file_path: Union[str, Path], is_initial_load: bool = True) -> None:
         """Load configuration from file with enhanced error handling.
@@ -161,11 +177,20 @@ class Config:
                 self._config = self._config_mgr.merge_configs(self._config, file_config)
                 # Track that we've successfully loaded from this file
                 self._actual_loaded_file = str(file_path)
+                
                 # Only log success message once using class-level flag to avoid duplicate messages
-                if is_initial_load and not Config._success_logged:
-                    logger.info(f"✓ Successfully loaded configuration from {file_path}")
-                    Config._success_logged = True
+                # Check if we should log success message (thread-safe for reads after initialization)
+                if is_initial_load:
+                    if not Config._success_logged:
+                        # Set flag IMMEDIATELY before logging to prevent any possibility of duplicate
+                        # messages. No lock needed here since we're already inside __init__ lock
+                        Config._success_logged = True
+                        logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                    else:
+                        # Configuration already successfully loaded before, just debug log
+                        logger.debug(f"Configuration already loaded, skipping success message for {file_path}")
                 else:
+                    # Not initial load (shouldn't happen in normal flow, but handle gracefully)
                     logger.debug(f"Configuration reloaded from {file_path}")
 
                 # Log important configuration values for debugging

claude_mpm/core/framework_loader.py

@@ -489,9 +489,25 @@ class FrameworkLoader:
                 memory_size = len(memory_content.encode('utf-8'))
                 self.logger.debug(f"Aggregated {agent_name} memory: {memory_size:,} bytes")
         
-        # Log summary
+        # Log detailed summary
         if loaded_count > 0 or skipped_count > 0:
-            self.logger.info(f"Memory loading complete: {loaded_count} memories loaded, {skipped_count} skipped")
+            # Count unique agents with memories
+            agent_count = len(agent_memories_dict) if agent_memories_dict else 0
+            pm_loaded = bool(content.get("actual_memories"))
+            
+            summary_parts = []
+            if pm_loaded:
+                summary_parts.append("PM memory loaded")
+            if agent_count > 0:
+                summary_parts.append(f"{agent_count} agent memories loaded")
+            if skipped_count > 0:
+                summary_parts.append(f"{skipped_count} non-deployed agent memories skipped")
+            
+            self.logger.info(f"Memory loading complete: {' | '.join(summary_parts)}")
+            
+            # Log deployed agents for reference
+            if len(deployed_agents) > 0:
+                self.logger.debug(f"Deployed agents available for memory loading: {', '.join(sorted(deployed_agents))}")
     
     def _load_memories_from_directory(
         self,
@@ -544,36 +560,36 @@ class FrameworkLoader:
                 self.logger.info(f"Loaded {source} PM memory: {pm_memory_path} ({memory_size:,} bytes)")
                 loaded_count += 1
         
-        # Load agent memories (only for deployed agents)
-        for memory_file in memories_dir.glob("*.md"):
-            # Skip PM_memories.md and PM.md as we already handled them
-            if memory_file.name in ["PM_memories.md", "PM.md"]:
+        # First, migrate any old format memory files to new format
+        # This handles backward compatibility for existing installations
+        for old_file in memories_dir.glob("*.md"):
+            # Skip files already in correct format and special files
+            if old_file.name.endswith("_memories.md") or old_file.name in ["PM.md", "README.md"]:
                 continue
             
-            # Extract agent name from file
-            # Support migration from old formats to new {agent_name}_memories.md format
-            agent_name = memory_file.stem
-            new_path = None
-            
-            if agent_name.endswith("_agent"):
-                # Old format: {agent_name}_agent.md
-                agent_name = agent_name[:-6]  # Remove "_agent" suffix
+            # Determine new name based on old format
+            if old_file.stem.endswith("_agent"):
+                # Old format: {agent_name}_agent.md -> {agent_name}_memories.md
+                agent_name = old_file.stem[:-6]  # Remove "_agent" suffix
                 new_path = memories_dir / f"{agent_name}_memories.md"
-            elif agent_name.endswith("_memories"):
-                # Already in new format: {agent_name}_memories.md
-                agent_name = agent_name[:-9]  # Remove "_memories" suffix
-            elif memory_file.name != "README.md":
-                # Intermediate format: {agent_name}.md
-                # agent_name already set from stem
+                if not new_path.exists():
+                    self._migrate_memory_file(old_file, new_path)
+            else:
+                # Intermediate format: {agent_name}.md -> {agent_name}_memories.md
+                agent_name = old_file.stem
                 new_path = memories_dir / f"{agent_name}_memories.md"
-            
-            # Skip README.md
-            if memory_file.name == "README.md":
+                if not new_path.exists():
+                    self._migrate_memory_file(old_file, new_path)
+        
+        # Load agent memories (only for deployed agents)
+        # Only process *_memories.md files to avoid README.md and other docs
+        for memory_file in memories_dir.glob("*_memories.md"):
+            # Skip PM_memories.md as we already handled it
+            if memory_file.name == "PM_memories.md":
                 continue
-                
-            # Migrate if needed
-            if new_path and not new_path.exists():
-                self._migrate_memory_file(memory_file, new_path)
+            
+            # Extract agent name from file (remove "_memories" suffix)
+            agent_name = memory_file.stem[:-9]  # Remove "_memories" suffix
             
             # Check if agent is deployed
             if agent_name in deployed_agents:
@@ -597,7 +613,17 @@ class FrameworkLoader:
                     self.logger.info(f"Loaded {source} memory for {agent_name}: {memory_file.name} ({memory_size:,} bytes)")
                     loaded_count += 1
             else:
-                self.logger.info(f"Skipped {source} memory: {memory_file.name} (agent not deployed)")
+                # Provide more detailed logging about why the memory was skipped
+                self.logger.info(f"Skipped {source} memory: {memory_file.name} (agent '{agent_name}' not deployed)")
+                # Also log a debug message with available agents for diagnostics
+                if agent_name.replace('_', '-') in deployed_agents or agent_name.replace('-', '_') in deployed_agents:
+                    # Detect naming mismatches
+                    alt_name = agent_name.replace('_', '-') if '_' in agent_name else agent_name.replace('-', '_')
+                    if alt_name in deployed_agents:
+                        self.logger.warning(
+                            f"Naming mismatch detected: Memory file uses '{agent_name}' but deployed agent is '{alt_name}'. "
+                            f"Consider renaming {memory_file.name} to {alt_name}_memories.md"
+                        )
                 skipped_count += 1
         
         # After loading all memories for this directory, aggregate agent memories
@@ -614,9 +640,10 @@ class FrameworkLoader:
         Aggregate multiple memory entries into a single memory string.
         
         Strategy:
-        - Parse memories by sections
-        - Merge sections, with project-level taking precedence
-        - Remove exact duplicates within sections
+        - Support both sectioned and non-sectioned memories
+        - Preserve all bullet-point items (lines starting with -)
+        - Merge sections when present, with project-level taking precedence
+        - Remove exact duplicates within sections and unsectioned items
         - Preserve unique entries from both sources
         
         Args:
@@ -632,15 +659,16 @@ class FrameworkLoader:
         if len(memory_entries) == 1:
             return memory_entries[0]["content"]
         
-        # Parse all memories into sections
+        # Parse all memories into sections and unsectioned items
         all_sections = {}
+        unsectioned_items = {}  # Items without a section header
         metadata_lines = []
         
         for entry in memory_entries:
             content = entry["content"]
             source = entry["source"]
             
-            # Parse content into sections
+            # Parse content into sections and unsectioned items
             current_section = None
             current_items = []
             
@@ -664,11 +692,25 @@ class FrameworkLoader:
                     # Start new section
                     current_section = line
                     current_items = []
-                # Check for content lines (skip empty lines)
-                elif line.strip() and current_section:
-                    current_items.append(line)
+                # Check for content lines (including unsectioned bullet points)
+                elif line.strip():
+                    # If it's a bullet point or regular content
+                    if current_section:
+                        # Add to current section
+                        current_items.append(line)
+                    elif line.strip().startswith('-'):
+                        # It's an unsectioned bullet point - preserve it
+                        # Use content as key to detect duplicates
+                        # Project source overrides user source
+                        if line not in unsectioned_items or source == "project":
+                            unsectioned_items[line] = source
+                    # Skip other non-bullet unsectioned content (like headers)
+                    elif not line.strip().startswith('#'):
+                        # Include non-header orphaned content in unsectioned items
+                        if line not in unsectioned_items or source == "project":
+                            unsectioned_items[line] = source
             
-            # Save last section
+            # Save last section if exists
             if current_section and current_items:
                 if current_section not in all_sections:
                     all_sections[current_section] = {}
@@ -691,6 +733,13 @@ class FrameworkLoader:
         lines.append("*This memory combines user-level and project-level memories.*")
         lines.append("")
         
+        # Add unsectioned items first (if any)
+        if unsectioned_items:
+            # Sort items to ensure consistent output
+            for item in sorted(unsectioned_items.keys()):
+                lines.append(item)
+            lines.append("")  # Empty line after unsectioned items
+        
         # Add sections
         for section_header in sorted(all_sections.keys()):
             lines.append(section_header)
@@ -1075,6 +1124,20 @@ class FrameworkLoader:
                 instructions += "**The following are your accumulated memories and knowledge from this project:**\n\n"
                 instructions += self.framework_content["actual_memories"]
                 instructions += "\n"
+            
+            # Add agent memories if available
+            if self.framework_content.get("agent_memories"):
+                agent_memories = self.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"
 
             # Add dynamic agent capabilities section
             instructions += self._generate_agent_capabilities_section()

claude_mpm/core/interactive_session.py

@@ -344,25 +344,36 @@ class InteractiveSession:
 
     def _build_claude_command(self) -> list:
         """Build the Claude command with all necessary arguments."""
-        cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+        # Check if --resume flag is present
+        has_resume = self.runner.claude_args and "--resume" in self.runner.claude_args
 
-        # Add custom arguments
-        if self.runner.claude_args:
-            # Enhanced debug logging for --resume flag verification
-            self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
-            
-            # Check explicitly for --resume flag
-            has_resume = "--resume" in self.runner.claude_args
-            self.logger.info(f"--resume flag present in claude_args: {has_resume}")
-            
-            cmd.extend(self.runner.claude_args)
-            
-        # Add system instructions
-        from claude_mpm.core.claude_runner import create_simple_context
+        if has_resume:
+            # When resuming, use minimal command to avoid interfering with conversation selection
+            self.logger.info("🔄 Resume mode detected - using minimal Claude command to preserve conversation selection")
+            cmd = ["claude"]
+
+            # Add only the claude_args (which includes --resume)
+            if self.runner.claude_args:
+                cmd.extend(self.runner.claude_args)
+                self.logger.info(f"Resume command: {cmd}")
+
+            return cmd
+        else:
+            # Normal mode - full command with all claude-mpm enhancements
+            cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+
+            # Add custom arguments
+            if self.runner.claude_args:
+                # Enhanced debug logging for --resume flag verification
+                self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
+                cmd.extend(self.runner.claude_args)
+
+            # Add system instructions
+            from claude_mpm.core.claude_runner import create_simple_context
 
-        system_prompt = self.runner._create_system_prompt()
-        if system_prompt and system_prompt != create_simple_context():
-            cmd.extend(["--append-system-prompt", system_prompt])
+            system_prompt = self.runner._create_system_prompt()
+            if system_prompt and system_prompt != create_simple_context():
+                cmd.extend(["--append-system-prompt", system_prompt])
 
         # Final command verification
         # self.logger.info(f"Final Claude command built: {' '.join(cmd)}")

claude_mpm/scripts/socketio_daemon.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 #!/usr/bin/env python3
 """
 Pure Python daemon management for Socket.IO server.
@@ -12,6 +10,64 @@ import signal
 import subprocess
 import sys
 import time
+from pathlib import Path
+
+# Detect and use virtual environment Python if available
+def get_python_executable():
+    """
+    Get the appropriate Python executable, preferring virtual environment.
+    
+    WHY: The daemon must use the same Python environment as the parent process
+    to ensure all dependencies are available. System Python won't have the
+    required packages installed.
+    """
+    # First, check if we're already in a virtual environment
+    if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+        # We're in a virtual environment, use its Python
+        return sys.executable
+    
+    # Check for common virtual environment indicators
+    # 1. VIRTUAL_ENV environment variable (most common)
+    venv_path = os.environ.get('VIRTUAL_ENV')
+    if venv_path:
+        venv_python = Path(venv_path) / 'bin' / 'python'
+        if venv_python.exists():
+            return str(venv_python)
+    
+    # 2. Check if current executable is in a venv directory structure
+    exe_path = Path(sys.executable).resolve()
+    for parent in exe_path.parents:
+        # Check for common venv directory names
+        if parent.name in ('venv', '.venv', 'env', '.env'):
+            # This looks like a virtual environment
+            return sys.executable
+        
+        # Check for typical venv structure (bin/python or Scripts/python.exe)
+        if parent.name == 'bin' and (parent.parent / 'pyvenv.cfg').exists():
+            return sys.executable
+        if parent.name == 'Scripts' and (parent.parent / 'pyvenv.cfg').exists():
+            return sys.executable
+    
+    # 3. Try to detect project-specific venv
+    # Look for venv in the project root (going up from script location)
+    script_path = Path(__file__).resolve()
+    for parent in script_path.parents:
+        # Stop at src or when we've gone too far up
+        if parent.name == 'src' or not (parent / 'src').exists():
+            # Check for venv directories
+            for venv_name in ('venv', '.venv', 'env', '.env'):
+                venv_dir = parent / venv_name
+                if venv_dir.exists():
+                    venv_python = venv_dir / 'bin' / 'python'
+                    if venv_python.exists():
+                        return str(venv_python)
+            break
+    
+    # Fall back to current Python executable
+    return sys.executable
+
+# Store the detected Python executable for daemon usage
+PYTHON_EXECUTABLE = get_python_executable()
 
 import psutil
 
@@ -145,11 +201,12 @@ def start_server():
 
     ensure_dirs()
 
-    # Fork to create daemon
+    # Fork to create daemon using the correct Python environment
     pid = os.fork()
     if pid > 0:
         # Parent process
         print(f"Starting Socket.IO server on port {selected_port} (PID: {pid})...")
+        print(f"Using Python: {PYTHON_EXECUTABLE}")
 
         # Register the instance
         instance_id = port_manager.register_instance(selected_port, pid)
@@ -179,10 +236,13 @@ def start_server():
         os.dup2(log.fileno(), sys.stdout.fileno())
         os.dup2(log.fileno(), sys.stderr.fileno())
 
-    # Start server
+    # Log environment information for debugging
     print(
         f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Starting Socket.IO server on port {selected_port}..."
     )
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python executable: {sys.executable}")
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python version: {sys.version}")
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python path: {sys.path[:3]}...")  # Show first 3 entries
     server = SocketIOServer(host="localhost", port=selected_port)
 
     # Handle signals
@@ -384,12 +444,12 @@ def main():
 
 
 if __name__ == "__main__":
-    # Install psutil if not available
+    # Install psutil if not available (using correct Python)
     try:
         import psutil
     except ImportError:
-        print("Installing psutil...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil"])
+        print(f"Installing psutil using {PYTHON_EXECUTABLE}...")
+        subprocess.check_call([PYTHON_EXECUTABLE, "-m", "pip", "install", "psutil"])
         import psutil
 
     main()