claude-mpm 4.5.6__py3-none-any.whl → 4.5.8__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.5.6
+4.5.8

claude_mpm/agents/BASE_OPS.md

@@ -4,6 +4,16 @@ All Ops agents inherit these common operational patterns and requirements.
 
 ## Core Ops Principles
 
+### Local Development Server Management
+**CRITICAL IMPERATIVES FOR LOCAL-OPS AGENTS:**
+- **MAINTAIN SINGLE STABLE INSTANCES**: Always strive to keep a single instance of each development server running stably. Avoid creating multiple instances of the same service.
+- **NEVER INTERRUPT OTHER PROJECTS**: Before stopping ANY service, verify it's not being used by another project or Claude Code session. Check process ownership and working directories.
+- **PROTECT CLAUDE CODE SERVICES**: Never terminate or interfere with Claude MPM services, monitor servers, or any processes that might be used by Claude Code.
+- **PORT MANAGEMENT**: Always check if a port is in use before attempting to use it. If occupied, find an alternative rather than killing the existing process.
+- **GRACEFUL OPERATIONS**: Use graceful shutdown procedures. Always attempt soft stops before forceful termination.
+- **SESSION AWARENESS**: Be aware that multiple Claude Code sessions might be active. Coordinate rather than conflict.
+- **HEALTH BEFORE ACTION**: Always verify service health before making changes. A running service should be left running unless explicitly requested to stop it.
+
 ### Infrastructure as Code
 - All infrastructure must be version controlled
 - Use declarative configuration over imperative scripts

claude_mpm/agents/PM_INSTRUCTIONS.md

@@ -164,9 +164,31 @@ Read: /mpm-doctor   # WRONG - not a file to read
 **User mentions error → PM delegates to Ops for logs (NEVER debugs)**
 **User wants analysis → PM delegates to Code Analyzer (NEVER analyzes)**
 
+### 🔥 LOCAL-OPS-AGENT PRIORITY RULE 🔥
+
+**MANDATORY**: For ANY localhost/local development work, ALWAYS use **local-ops-agent** as the PRIMARY choice:
+- **Local servers**: localhost:3000, dev servers → **local-ops-agent** (NOT generic Ops)
+- **PM2 operations**: pm2 start/stop/status → **local-ops-agent** (EXPERT in PM2)
+- **Port management**: Port conflicts, EADDRINUSE → **local-ops-agent** (HANDLES gracefully)
+- **npm/yarn/pnpm**: npm start, yarn dev → **local-ops-agent** (PREFERRED)
+- **Process management**: ps, kill, restart → **local-ops-agent** (SAFE operations)
+- **Docker local**: docker-compose up → **local-ops-agent** (MANAGES containers)
+
+**WHY local-ops-agent?**
+- Maintains single stable instances (no duplicates)
+- Never interrupts other projects or Claude Code
+- Smart port allocation (finds alternatives, doesn't kill)
+- Graceful operations (soft stops, proper cleanup)
+- Session-aware (coordinates with multiple Claude sessions)
+
 ### Quick Delegation Matrix
 | User Says | PM's IMMEDIATE Response | You MUST Delegate To |
 |-----------|------------------------|---------------------|
+| "localhost", "local server", "dev server" | "I'll delegate to local-ops agent" | **local-ops-agent** (PRIMARY) |
+| "PM2", "process manager", "pm2 start" | "I'll have local-ops manage PM2" | **local-ops-agent** (ALWAYS) |
+| "port 3000", "port conflict", "EADDRINUSE" | "I'll have local-ops handle ports" | **local-ops-agent** (EXPERT) |
+| "npm start", "npm run dev", "yarn dev" | "I'll have local-ops run the dev server" | **local-ops-agent** (PREFERRED) |
+| "start my app", "run locally" | "I'll delegate to local-ops agent" | **local-ops-agent** (DEFAULT) |
 | "fix", "implement", "code", "create" | "I'll delegate this to Engineer" | Engineer |
 | "test", "verify", "check" | "I'll have QA verify this" | QA (or web-qa/api-qa) |
 | "deploy", "host", "launch" | "I'll delegate to Ops" | Ops (or platform-specific) |
@@ -245,7 +267,8 @@ START → [DELEGATE Research] → [DELEGATE Code Analyzer] → [DELEGATE Impleme
 
 | Deployment Type | Ops Agent | Required Verifications |
 |----------------|-----------|------------------------|
-| Local Dev (PM2, Docker) | Ops | Read logs, check process status, fetch endpoint, Playwright if UI |
+| Local Dev (PM2, Docker) | **local-ops-agent** (PRIMARY) | Read logs, check process status, fetch endpoint, Playwright if UI |
+| Local npm/yarn/pnpm | **local-ops-agent** (ALWAYS) | Process monitoring, port management, graceful operations |
 | Vercel | vercel-ops-agent | Read build logs, fetch deployment URL, check function logs, Playwright for pages |
 | Railway | railway-ops-agent | Read deployment logs, check health endpoint, verify database connections |
 | GCP/Cloud Run | gcp-ops-agent | Check Cloud Run logs, verify service status, test endpoints |
@@ -274,9 +297,10 @@ Requirements:
 ## LOCAL DEPLOYMENT MANDATORY VERIFICATION
 
 **CRITICAL**: PM MUST NEVER claim "running on localhost" without verification.
+**PRIMARY AGENT**: Always use **local-ops-agent** for ALL localhost work.
 
 ### Required for ALL Local Deployments (PM2, Docker, npm start, etc.):
-1. PM MUST delegate to local-ops-agent (or Ops) for deployment
+1. PM MUST delegate to **local-ops-agent** (NEVER generic Ops) for deployment
 2. Ops agent MUST verify with ALL of these:
    - Process status check (ps, pm2 status, docker ps)
    - Log examination for startup errors
@@ -309,7 +333,7 @@ These phrases without fetch evidence = IMMEDIATE VIOLATION:
 |------|-------------|----------|----------------|
 | API | HTTP calls | curl/fetch output | web-qa (MANDATORY) |
 | Web UI | Browser automation | Playwright results | web-qa with Playwright |
-| Local Deploy | PM2/Docker status + fetch/Playwright | Logs + endpoint tests | Ops (MUST verify) |
+| Local Deploy | PM2/Docker status + fetch/Playwright | Logs + endpoint tests | **local-ops-agent** (MUST verify) |
 | Vercel Deploy | Build success + fetch/Playwright | Deployment URL active | vercel-ops-agent (MUST verify) |
 | Railway Deploy | Service healthy + fetch tests | Logs + endpoint response | railway-ops-agent (MUST verify) |
 | GCP Deploy | Cloud Run active + endpoint tests | Service logs + HTTP 200 | gcp-ops-agent (MUST verify) |
@@ -597,7 +621,7 @@ Documentation → Report
 - Web UI: Research → Analyzer → web-ui/react-engineer → Ops (deploy) → Ops (VERIFY with Playwright) → web-qa → Docs
 - Vercel Site: Research → Analyzer → Engineer → vercel-ops (deploy) → vercel-ops (VERIFY) → web-qa → Docs
 - Railway App: Research → Analyzer → Engineer → railway-ops (deploy) → railway-ops (VERIFY) → api-qa → Docs
-- Local Dev: Research → Analyzer → Engineer → Ops (PM2/Docker) → Ops (VERIFY logs+fetch) → QA → Docs
+- Local Dev: Research → Analyzer → Engineer → **local-ops-agent** (PM2/Docker) → **local-ops-agent** (VERIFY logs+fetch) → QA → Docs
 - Bug Fix: Research → Analyzer → Engineer → Deploy → Ops (VERIFY) → web-qa (regression) → version-control
 
 ### Success Criteria

claude_mpm/agents/templates/local_ops_agent.json

@@ -1,8 +1,8 @@
 {
   "name": "local-ops",
   "display_name": "Local Operations Agent",
-  "description": "Specialized agent for managing local development deployments with authority over PM2, Docker, and native processes",
-  "version": "1.0.0",
+  "description": "Specialized agent for managing local development deployments with focus on maintaining single stable instances, protecting existing services, and never interfering with other projects or Claude Code services",
+  "version": "1.0.1",
   "author": "Claude MPM",
   "authority": {
     "level": "deployment_manager",
@@ -65,7 +65,16 @@
     "state_file": ".claude-mpm/deployment-state.json",
     "health_check_interval": 30,
     "auto_restart_attempts": 3,
-    "cleanup_on_exit": false
+    "cleanup_on_exit": false,
+    "stability_policy": {
+      "single_instance_enforcement": true,
+      "reuse_existing_processes": true,
+      "protect_external_services": true,
+      "avoid_port_conflicts": true,
+      "graceful_shutdown_timeout": 10000,
+      "check_process_ownership": true,
+      "preserve_claude_mpm_services": true
+    }
   },
   "commands": {
     "deploy": {
@@ -78,9 +87,11 @@
       "workflow": [
         "detect_framework",
         "check_existing_deployments",
-        "allocate_port",
+        "verify_no_conflicts",
+        "check_process_ownership",
+        "reuse_or_allocate_port",
         "build_if_needed",
-        "start_process",
+        "start_or_attach_to_process",
         "monitor_health",
         "report_status"
       ]
@@ -213,7 +224,23 @@
   "error_recovery": {
     "port_conflict": {
       "detection": "EADDRINUSE",
-      "action": "allocate_next_available_port"
+      "action": "check_process_owner_then_allocate_alternative_port",
+      "never": "kill_existing_process_without_verification"
+    },
+    "existing_service": {
+      "detection": "service_already_running",
+      "action": "attach_to_existing_or_report_status",
+      "never": "create_duplicate_instance"
+    },
+    "external_ownership": {
+      "detection": "process_owned_by_other_project",
+      "action": "allocate_different_resources",
+      "never": "interfere_with_external_process"
+    },
+    "claude_mpm_service": {
+      "detection": "claude-mpm|mcp|monitor",
+      "action": "report_status_only",
+      "never": "stop_or_restart_system_services"
     },
     "build_failure": {
       "detection": "npm ERR!|ERROR|Failed",
@@ -235,11 +262,20 @@
     "secrets_handling": "environment_variables"
   },
   "integration": {
+    "operational_principles": {
+      "single_instance_policy": "Always maintain single stable instances of services",
+      "non_interference": "Never interrupt services owned by other projects or Claude Code",
+      "service_protection": "Protect all Claude MPM, MCP, and monitor services",
+      "graceful_operations": "Always prefer graceful operations over forceful actions",
+      "conflict_avoidance": "Find alternative resources rather than stopping existing services"
+    },
     "hooks": {
-      "pre_deploy": "validate_requirements",
+      "pre_deploy": "check_conflicts_and_validate_requirements",
       "post_deploy": "notify_status",
-      "pre_stop": "graceful_shutdown",
-      "on_crash": "auto_restart_with_backoff"
+      "pre_stop": "verify_ownership_then_graceful_shutdown",
+      "on_crash": "auto_restart_with_backoff",
+      "before_port_use": "check_existing_process_owner",
+      "on_conflict": "find_alternative_resources"
     },
     "monitoring": {
       "export_metrics": true,

claude_mpm/services/async_session_logger.py

@@ -31,6 +31,9 @@ from typing import Any, Dict, Optional
 from claude_mpm.core.constants import PerformanceConfig, SystemLimits, TimeoutConfig
 from claude_mpm.core.logging_utils import get_logger
 
+# Import centralized session manager
+from claude_mpm.services.session_manager import get_session_manager
+
 # Import configuration manager
 from ..core.config import Config
 
@@ -68,8 +71,13 @@ class AsyncSessionLogger:
     - Configurable log formats (JSON, syslog, journald)
     - Fire-and-forget pattern for zero latency impact
     - Graceful degradation on errors
+    - Thread-safe singleton pattern with initialization flag
     """
 
+    _initialization_lock = Lock()
+    _initialized = False
+    _worker_started = False
+
     def __init__(
         self,
         base_dir: Optional[Path] = None,
@@ -90,109 +98,108 @@ class AsyncSessionLogger:
             enable_compression: Enable gzip compression for JSON logs (overrides config)
             config: Configuration instance to use (creates new if not provided)
         """
-        # Load configuration from YAML file or use provided config
-        if config is None:
-            config = Config()
-        self.config = config
-
-        # Get response logging configuration section
-        response_config = self.config.get("response_logging", {})
-
-        # Apply configuration with parameter overrides
-        self.base_dir = Path(
-            base_dir
-            or response_config.get("session_directory", ".claude-mpm/responses")
-        )
-
-        # Convert log format string to enum
-        format_str = response_config.get("format", "json").lower()
-        if log_format is not None:
-            self.log_format = log_format
-        elif format_str == "syslog":
-            self.log_format = LogFormat.SYSLOG
-        elif format_str == "journald":
-            self.log_format = LogFormat.JOURNALD
-        else:
-            self.log_format = LogFormat.JSON
-
-        self.max_queue_size = (
-            max_queue_size
-            if max_queue_size is not None
-            else response_config.get("max_queue_size", SystemLimits.MAX_QUEUE_SIZE)
-        )
-
-        # Handle async configuration with backward compatibility
-        if enable_async is not None:
-            self.enable_async = enable_async
-        else:
-            # Check configuration first, then environment variables for backward compatibility
-            self.enable_async = response_config.get("use_async", True)
-            # Override with environment variable if set (backward compatibility)
-            if os.environ.get("CLAUDE_USE_ASYNC_LOG"):
-                self.enable_async = (
-                    os.environ.get("CLAUDE_USE_ASYNC_LOG", "true").lower() == "true"
-                )
-
-        # Check debug sync mode (forces synchronous for debugging)
-        if (
-            response_config.get("debug_sync", False)
-            or os.environ.get("CLAUDE_LOG_SYNC", "").lower() == "true"
-        ):
-            logger.info("Debug sync mode enabled - forcing synchronous logging")
-            self.enable_async = False
-
-        self.enable_compression = (
-            enable_compression
-            if enable_compression is not None
-            else response_config.get("enable_compression", False)
-        )
+        # Use initialization flag to prevent duplicate setup
+        with self._initialization_lock:
+            if self._initialized and hasattr(self, "config"):
+                logger.debug("AsyncSessionLogger already initialized, skipping setup")
+                return
 
-        # Create base directory
-        self.base_dir.mkdir(parents=True, exist_ok=True)
+            # Load configuration from YAML file or use provided config
+            if config is None:
+                config = Config()
+            self.config = config
 
-        # Session management
-        self.session_id = self._get_claude_session_id()
+            # Get response logging configuration section
+            response_config = self.config.get("response_logging", {})
 
-        # Async infrastructure
-        self._queue: Queue = Queue(maxsize=self.max_queue_size)
-        self._worker_thread: Optional[Thread] = None
-        self._shutdown = False
-        self._lock = Lock()
+            # Apply configuration with parameter overrides
+            self.base_dir = Path(
+                base_dir
+                or response_config.get("session_directory", ".claude-mpm/responses")
+            )
 
-        # Statistics
-        self.stats = {
-            "logged": 0,
-            "queued": 0,
-            "dropped": 0,
-            "errors": 0,
-            "avg_write_time_ms": 0.0,
-        }
+            # Convert log format string to enum
+            format_str = response_config.get("format", "json").lower()
+            if log_format is not None:
+                self.log_format = log_format
+            elif format_str == "syslog":
+                self.log_format = LogFormat.SYSLOG
+            elif format_str == "journald":
+                self.log_format = LogFormat.JOURNALD
+            else:
+                self.log_format = LogFormat.JSON
 
-        # Initialize format-specific handlers
-        self._init_format_handler()
+            self.max_queue_size = (
+                max_queue_size
+                if max_queue_size is not None
+                else response_config.get("max_queue_size", SystemLimits.MAX_QUEUE_SIZE)
+            )
 
-        # Start background worker if async enabled
-        if self.enable_async:
-            self._start_worker()
+            # Handle async configuration with backward compatibility
+            if enable_async is not None:
+                self.enable_async = enable_async
+            else:
+                # Check configuration first, then environment variables for backward compatibility
+                self.enable_async = response_config.get("use_async", True)
+                # Override with environment variable if set (backward compatibility)
+                if os.environ.get("CLAUDE_USE_ASYNC_LOG"):
+                    self.enable_async = (
+                        os.environ.get("CLAUDE_USE_ASYNC_LOG", "true").lower() == "true"
+                    )
 
-        # Log initialization status
-        logger.info(
-            f"AsyncSessionLogger initialized: session_id={self.session_id}, async={self.enable_async}, format={self.log_format.value}"
-        )
+            # Check debug sync mode (forces synchronous for debugging)
+            if (
+                response_config.get("debug_sync", False)
+                or os.environ.get("CLAUDE_LOG_SYNC", "").lower() == "true"
+            ):
+                logger.info("Debug sync mode enabled - forcing synchronous logging")
+                self.enable_async = False
+
+            self.enable_compression = (
+                enable_compression
+                if enable_compression is not None
+                else response_config.get("enable_compression", False)
+            )
 
-    def _get_claude_session_id(self) -> str:
-        """Get or generate a Claude session ID."""
-        # Check environment variables in order of preference
-        for env_var in ["CLAUDE_SESSION_ID", "ANTHROPIC_SESSION_ID", "SESSION_ID"]:
-            session_id = os.environ.get(env_var)
-            if session_id:
-                logger.info(f"Using session ID from {env_var}: {session_id}")
-                return session_id
+            # Create base directory
+            self.base_dir.mkdir(parents=True, exist_ok=True)
+
+            # Use centralized SessionManager for session ID
+            session_manager = get_session_manager()
+            self.session_id = session_manager.get_session_id()
+
+            # Async infrastructure
+            self._queue: Queue = Queue(maxsize=self.max_queue_size)
+            self._worker_thread: Optional[Thread] = None
+            self._shutdown = False
+            self._lock = Lock()
+
+            # Statistics
+            self.stats = {
+                "logged": 0,
+                "queued": 0,
+                "dropped": 0,
+                "errors": 0,
+                "avg_write_time_ms": 0.0,
+            }
+
+            # Initialize format-specific handlers
+            self._init_format_handler()
+
+            # Mark as initialized
+            self._initialized = True
+
+            # Log initialization status
+            logger.info(
+                f"AsyncSessionLogger initialized with SessionManager: session_id={self.session_id}, async={self.enable_async}, format={self.log_format.value}"
+            )
 
-        # Generate timestamp-based session ID
-        session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-        logger.info(f"Generated session ID: {session_id}")
-        return session_id
+        # Start background worker if async enabled (outside initialization lock)
+        if self.enable_async and not self._worker_started:
+            with self._initialization_lock:
+                if not self._worker_started:
+                    self._start_worker()
+                    self._worker_started = True
 
     def _init_format_handler(self):
         """Initialize format-specific logging handlers."""
@@ -519,8 +526,17 @@ class AsyncSessionLogger:
             return self.stats.copy()
 
     def set_session_id(self, session_id: str):
-        """Set a new session ID."""
+        """Set a new session ID.
+
+        Note: This updates both the local session ID and the SessionManager.
+
+        Args:
+            session_id: The new session ID to use
+        """
         self.session_id = session_id
+        # Also update SessionManager to keep consistency
+        session_manager = get_session_manager()
+        session_manager.set_session_id(session_id)
         logger.info(f"Session ID updated to: {session_id}")
 
     def is_enabled(self) -> bool:

claude_mpm/services/claude_session_logger.py

@@ -13,11 +13,15 @@ Configuration via .claude-mpm/configuration.yaml.
 import json
 import os
 from datetime import datetime, timezone
+from threading import Lock
 from typing import Any, Dict, Optional
 
 # Import configuration manager
 from claude_mpm.core.config import Config
 
+# Import centralized session manager
+from claude_mpm.services.session_manager import get_session_manager
+
 # Try to import async logger for performance optimization
 try:
     from claude_mpm.services.async_session_logger import (
@@ -38,6 +42,9 @@ logger = get_logger(__name__)
 class ClaudeSessionLogger:
     """Simplified response logger for Claude Code sessions."""
 
+    _initialization_lock = Lock()
+    _initialized = False
+
     def __init__(
         self,
         base_dir: Optional[Path] = None,
@@ -52,29 +59,41 @@ class ClaudeSessionLogger:
             use_async: Use async logging if available. Overrides config.
             config: Configuration instance to use (creates new if not provided)
         """
-        # Load configuration
-        if config is None:
-            config = Config()
-        self.config = config
-
-        # Get response logging configuration
-        response_config = self.config.get("response_logging", {})
-
-        # Determine base directory
-        if base_dir is None:
-            # Check configuration first
-            base_dir = response_config.get("session_directory")
-            if not base_dir:
-                # Fall back to default response directory
-                base_dir = ".claude-mpm/responses"
-            base_dir = Path(base_dir)
-
-        self.base_dir = Path(base_dir)
-        self.base_dir.mkdir(parents=True, exist_ok=True)
+        # Use initialization flag to prevent duplicate setup
+        with self._initialization_lock:
+            if self._initialized and hasattr(self, "config"):
+                logger.debug("ClaudeSessionLogger already initialized, skipping setup")
+                return
+
+            # Load configuration
+            if config is None:
+                config = Config()
+            self.config = config
+
+            # Get response logging configuration
+            response_config = self.config.get("response_logging", {})
+
+            # Determine base directory
+            if base_dir is None:
+                # Check configuration first
+                base_dir = response_config.get("session_directory")
+                if not base_dir:
+                    # Fall back to default response directory
+                    base_dir = ".claude-mpm/responses"
+                base_dir = Path(base_dir)
+
+            self.base_dir = Path(base_dir)
+            self.base_dir.mkdir(parents=True, exist_ok=True)
+
+            # Use centralized SessionManager for session ID
+            session_manager = get_session_manager()
+            self.session_id = session_manager.get_session_id()
+            logger.info(
+                f"ClaudeSessionLogger using session ID from SessionManager: {self.session_id}"
+            )
 
-        # Try to get session ID from environment
-        self.session_id = self._get_claude_session_id()
-        self.response_counter = {}  # Track response count per session
+            self.response_counter = {}  # Track response count per session
+            self._initialized = True
 
         # Determine if we should use async logging
         if use_async is None:
@@ -117,38 +136,6 @@ class ClaudeSessionLogger:
                 )
                 self.use_async = False
 
-    def _get_claude_session_id(self) -> Optional[str]:
-        """
-        Get the Claude Code session ID from environment.
-
-        Returns:
-            Session ID if available, None otherwise
-        """
-        # Claude Code may set various environment variables
-        # Check common patterns
-        session_id = None
-
-        # Check for CLAUDE_SESSION_ID
-        session_id = os.environ.get("CLAUDE_SESSION_ID")
-
-        # Check for ANTHROPIC_SESSION_ID
-        if not session_id:
-            session_id = os.environ.get("ANTHROPIC_SESSION_ID")
-
-        # Check for generic SESSION_ID
-        if not session_id:
-            session_id = os.environ.get("SESSION_ID")
-
-        # Generate a default based on timestamp if nothing found
-        if not session_id:
-            # Use a timestamp-based session ID as fallback
-            session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            logger.info(f"Session ID: {session_id} (generated)")
-        else:
-            logger.info(f"Session ID: {session_id}")
-
-        return session_id
-
     def _generate_filename(self, agent: Optional[str] = None) -> str:
         """
         Generate a flat filename with session ID, agent, and timestamp.
@@ -251,10 +238,15 @@ class ClaudeSessionLogger:
         """
         Manually set the session ID.
 
+        Note: This updates both the local session ID and the SessionManager.
+
         Args:
             session_id: The session ID to use
         """
         self.session_id = session_id
+        # Also update SessionManager to keep consistency
+        session_manager = get_session_manager()
+        session_manager.set_session_id(session_id)
         logger.info(f"Session ID set to: {session_id}")
 
     def get_session_path(self) -> Optional[Path]:
@@ -280,13 +272,16 @@ class ClaudeSessionLogger:
         return self.session_id is not None
 
 
-# Singleton instance for easy access
+# Singleton instance with thread-safe initialization
 _logger_instance = None
+_logger_lock = Lock()
 
 
 def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
     """
-    Get the singleton session logger instance.
+    Get the singleton session logger instance with thread-safe initialization.
+
+    Uses double-checked locking pattern to ensure thread safety.
 
     Args:
         config: Optional configuration instance to use
@@ -295,9 +290,16 @@ def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
         The shared ClaudeSessionLogger instance
     """
     global _logger_instance
-    if _logger_instance is None:
-        _logger_instance = ClaudeSessionLogger(config=config)
-    return _logger_instance
+
+    # Fast path - check without lock
+    if _logger_instance is not None:
+        return _logger_instance
+
+    # Slow path - acquire lock and double-check
+    with _logger_lock:
+        if _logger_instance is None:
+            _logger_instance = ClaudeSessionLogger(config=config)
+        return _logger_instance
 
 
 def log_response(

claude_mpm/services/mcp_config_manager.py

@@ -41,6 +41,14 @@ class MCPConfigManager:
         "kuzu-memory",
     }
 
+    # Known missing dependencies for MCP services that pipx doesn't handle automatically
+    # Maps service names to list of missing dependencies that need injection
+    SERVICE_MISSING_DEPENDENCIES = {
+        "mcp-ticketer": ["gql"],  # mcp-ticketer v0.1.8+ needs gql but doesn't declare it
+        # Add more services here as needed, e.g.:
+        # "another-service": ["dep1", "dep2"],
+    }
+
     # Static known-good MCP service configurations
     # These are the correct, tested configurations that work reliably
     # Note: Commands will be resolved to full paths dynamically in get_static_service_config()
@@ -943,6 +951,11 @@ class MCPConfigManager:
                 )
 
                 if result.returncode == 0:
+                    # Inject any missing dependencies if needed
+                    if service_name in self.SERVICE_MISSING_DEPENDENCIES:
+                        self.logger.debug(f"Injecting missing dependencies for newly installed {service_name}...")
+                        self._inject_missing_dependencies(service_name)
+
                     # Verify installation worked
                     if self._verify_service_installed(service_name, "pipx"):
                         return True, "pipx"
@@ -1092,18 +1105,39 @@ class MCPConfigManager:
                     failed_services.append(f"{service_name} (reinstall failed)")
 
             elif issue_type == "missing_dependency":
-                # Fix missing dependencies by automatically reinstalling
+                # Fix missing dependencies - try injection first, then reinstall if needed
                 self.logger.info(
-                    f"  {service_name} has missing dependencies - auto-reinstalling..."
+                    f"  {service_name} has missing dependencies - attempting fix..."
                 )
+
+                # First try to inject dependencies without reinstalling
+                injection_success = self._inject_missing_dependencies(service_name)
+
+                if injection_success:
+                    # Verify the fix worked
+                    issue_after_injection = self._detect_service_issue(service_name)
+                    if issue_after_injection is None:
+                        fixed_services.append(f"{service_name} (dependencies injected)")
+                        self.logger.info(f"  ✅ Fixed {service_name} with dependency injection")
+                        continue  # Move to next service
+
+                # If injection alone didn't work, try full reinstall
+                self.logger.info("  Dependency injection insufficient, trying full reinstall...")
                 success = self._auto_reinstall_mcp_service(service_name)
                 if success:
-                    fixed_services.append(f"{service_name} (auto-reinstalled)")
+                    fixed_services.append(f"{service_name} (auto-reinstalled with dependencies)")
                 else:
-                    self.logger.warning(
-                        f"  Auto-reinstall failed for {service_name}. Manual fix: "
-                        f"pipx uninstall {service_name} && pipx install {service_name}"
-                    )
+                    # Provide specific manual fix for known services
+                    if service_name == "mcp-ticketer":
+                        self.logger.warning(
+                            f"  Auto-fix failed for {service_name}. Manual fix: "
+                            f"pipx uninstall {service_name} && pipx install {service_name} && pipx inject {service_name} gql"
+                        )
+                    else:
+                        self.logger.warning(
+                            f"  Auto-reinstall failed for {service_name}. Manual fix: "
+                            f"pipx uninstall {service_name} && pipx install {service_name}"
+                        )
                     failed_services.append(f"{service_name} (auto-reinstall failed)")
 
             elif issue_type == "path_issue":
@@ -1129,7 +1163,11 @@ class MCPConfigManager:
             message += "\n\n💡 Manual fix instructions:"
             for failed in failed_services:
                 service = failed.split(" ")[0]
-                message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
+                if service in self.SERVICE_MISSING_DEPENDENCIES:
+                    deps = " ".join([f"&& pipx inject {service} {dep}" for dep in self.SERVICE_MISSING_DEPENDENCIES[service]])
+                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service} {deps}"
+                else:
+                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
 
         return success, message
 
@@ -1148,7 +1186,58 @@ class MCPConfigManager:
 
         # Try to run the service with --help to detect issues
         try:
-            # Test with pipx run
+            # First check if service is installed in pipx venv
+            pipx_venv_bin = self.pipx_base / service_name / "bin" / service_name
+            if pipx_venv_bin.exists():
+                # Test the installed version directly (has injected dependencies)
+                # This avoids using pipx run which downloads a fresh cache copy without dependencies
+                self.logger.debug(f"Testing {service_name} from installed pipx venv: {pipx_venv_bin}")
+                result = subprocess.run(
+                    [str(pipx_venv_bin), "--help"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                    check=False,
+                )
+
+                # Check for specific error patterns in installed version
+                stderr_lower = result.stderr.lower()
+                stdout_lower = result.stdout.lower()
+                combined_output = stderr_lower + stdout_lower
+
+                # Import errors in installed version (should be rare if dependencies injected)
+                if (
+                    "modulenotfounderror" in combined_output
+                    or "importerror" in combined_output
+                ):
+                    # Check if it's specifically the gql dependency for mcp-ticketer
+                    if service_name == "mcp-ticketer" and "gql" in combined_output:
+                        return "missing_dependency"
+                    return "import_error"
+
+                # Path issues
+                if "no such file or directory" in combined_output:
+                    return "path_issue"
+
+                # If help text appears, service is working
+                if (
+                    "usage:" in combined_output
+                    or "help" in combined_output
+                    or result.returncode in [0, 1]
+                ):
+                    self.logger.debug(f"{service_name} is working correctly")
+                    return None  # Service is working
+
+                # Unknown issue
+                if result.returncode not in [0, 1]:
+                    self.logger.debug(f"{service_name} returned unexpected exit code: {result.returncode}")
+                    return "unknown_error"
+
+                return None  # Default to working if no issues detected
+
+            # Service not installed in pipx venv - use pipx run for detection
+            # Note: pipx run uses cache which may not have injected dependencies
+            self.logger.debug(f"Testing {service_name} via pipx run (not installed in venv)")
             result = subprocess.run(
                 ["pipx", "run", service_name, "--help"],
                 capture_output=True,
@@ -1169,15 +1258,15 @@ class MCPConfigManager:
             ):
                 return "not_installed"
 
-            # Import errors (like mcp-ticketer's corrupted state)
+            # Import errors when using pipx run (cache version)
             if (
                 "modulenotfounderror" in combined_output
                 or "importerror" in combined_output
             ):
-                # Check if it's specifically the gql dependency for mcp-ticketer
-                if service_name == "mcp-ticketer" and "gql" in combined_output:
-                    return "missing_dependency"
-                return "import_error"
+                # Don't report missing_dependency for cache version - it may be missing injected deps
+                # Just report that service needs to be installed properly
+                self.logger.debug(f"{service_name} has import errors in pipx run cache - needs proper installation")
+                return "not_installed"
 
             # Path issues
             if "no such file or directory" in combined_output:
@@ -1240,6 +1329,11 @@ class MCPConfigManager:
             )
 
             if install_result.returncode == 0:
+                # Inject any missing dependencies if needed
+                if service_name in self.SERVICE_MISSING_DEPENDENCIES:
+                    self.logger.debug(f"Injecting missing dependencies for {service_name}...")
+                    self._inject_missing_dependencies(service_name)
+
                 # Verify the reinstall worked
                 issue = self._detect_service_issue(service_name)
                 if issue is None:
@@ -1258,6 +1352,65 @@ class MCPConfigManager:
             self.logger.error(f"Error reinstalling {service_name}: {e}")
             return False
 
+    def _inject_missing_dependencies(self, service_name: str) -> bool:
+        """
+        Inject missing dependencies into a pipx-installed MCP service.
+
+        Some MCP services don't properly declare all their dependencies in their
+        package metadata, which causes import errors when pipx creates isolated
+        virtual environments. This method injects the missing dependencies using
+        pipx inject.
+
+        Args:
+            service_name: Name of the MCP service to fix
+
+        Returns:
+            True if dependencies were injected successfully or no injection needed, False otherwise
+        """
+        # Check if this service has known missing dependencies
+        if service_name not in self.SERVICE_MISSING_DEPENDENCIES:
+            return True  # No dependencies to inject
+
+        missing_deps = self.SERVICE_MISSING_DEPENDENCIES[service_name]
+        if not missing_deps:
+            return True  # No dependencies to inject
+
+        self.logger.info(
+            f"  → Injecting missing dependencies for {service_name}: {', '.join(missing_deps)}"
+        )
+
+        all_successful = True
+        for dep in missing_deps:
+            try:
+                self.logger.debug(f"    Injecting {dep} into {service_name}...")
+                result = subprocess.run(
+                    ["pipx", "inject", service_name, dep],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                    check=False,
+                )
+
+                if result.returncode == 0:
+                    self.logger.info(f"    ✅ Successfully injected {dep}")
+                # Check if already injected (pipx will complain if package already exists)
+                elif "already satisfied" in result.stderr.lower() or "already installed" in result.stderr.lower():
+                    self.logger.debug(f"    {dep} already present in {service_name}")
+                else:
+                    self.logger.error(
+                        f"    Failed to inject {dep}: {result.stderr}"
+                    )
+                    all_successful = False
+
+            except subprocess.TimeoutExpired:
+                self.logger.error(f"    Timeout while injecting {dep}")
+                all_successful = False
+            except Exception as e:
+                self.logger.error(f"    Error injecting {dep}: {e}")
+                all_successful = False
+
+        return all_successful
+
     def _auto_reinstall_mcp_service(self, service_name: str) -> bool:
         """
         Automatically reinstall an MCP service with missing dependencies.
@@ -1312,6 +1465,14 @@ class MCPConfigManager:
                 )
                 return False
 
+            # Inject any missing dependencies that pipx doesn't handle automatically
+            if service_name in self.SERVICE_MISSING_DEPENDENCIES:
+                self.logger.info(f"  → Fixing missing dependencies for {service_name}...")
+                if not self._inject_missing_dependencies(service_name):
+                    self.logger.warning(
+                        f"Failed to inject all dependencies for {service_name}, but continuing..."
+                    )
+
             # Verify the reinstall worked
             self.logger.info(f"  → Verifying {service_name} installation...")
             issue = self._detect_service_issue(service_name)
@@ -1319,9 +1480,17 @@ class MCPConfigManager:
             if issue is None:
                 self.logger.info(f"  ✅ Successfully reinstalled {service_name}")
                 return True
-            self.logger.warning(
-                f"Reinstalled {service_name} but still has issue: {issue}"
-            )
+
+            # If still has missing dependency issue after injection, log specific instructions
+            if issue == "missing_dependency" and service_name == "mcp-ticketer":
+                self.logger.error(
+                    f"  {service_name} still has missing dependencies after injection. "
+                    f"Manual fix: pipx inject {service_name} gql"
+                )
+            else:
+                self.logger.warning(
+                    f"Reinstalled {service_name} but still has issue: {issue}"
+                )
             return False
 
         except subprocess.TimeoutExpired:

claude_mpm/services/response_tracker.py

@@ -19,6 +19,7 @@ DESIGN DECISIONS:
 """
 
 from datetime import datetime, timezone
+from threading import Lock
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.config import Config
@@ -214,12 +215,15 @@ class ResponseTracker:
             logger.info(f"Response tracker session ID set to: {session_id}")
 
 
-# Singleton instance for consistency
+# Singleton instance with thread-safe initialization
 _tracker_instance = None
+_tracker_lock = Lock()
 
 
 def get_response_tracker(config: Optional[Config] = None) -> ResponseTracker:
-    """Get the singleton response tracker instance.
+    """Get the singleton response tracker instance with thread-safe initialization.
+
+    Uses double-checked locking pattern to ensure thread safety.
 
     Args:
         config: Optional configuration instance
@@ -228,9 +232,16 @@ def get_response_tracker(config: Optional[Config] = None) -> ResponseTracker:
         The shared ResponseTracker instance
     """
     global _tracker_instance
-    if _tracker_instance is None:
-        _tracker_instance = ResponseTracker(config=config)
-    return _tracker_instance
+
+    # Fast path - check without lock
+    if _tracker_instance is not None:
+        return _tracker_instance
+
+    # Slow path - acquire lock and double-check
+    with _tracker_lock:
+        if _tracker_instance is None:
+            _tracker_instance = ResponseTracker(config=config)
+        return _tracker_instance
 
 
 def track_response(

claude_mpm/services/session_manager.py

@@ -0,0 +1,174 @@
+"""
+Session Manager Service
+
+Centralized session ID management with thread-safe singleton pattern.
+Ensures a single session ID is generated and used across all components.
+
+This service addresses race conditions and duplicate session ID generation
+by providing a single source of truth for session identifiers.
+"""
+
+import os
+from datetime import datetime, timezone
+from threading import Lock
+from typing import Optional
+
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class SessionManager:
+    """
+    Thread-safe singleton session manager.
+
+    Provides centralized session ID generation and management to prevent
+    duplicate session IDs across different components.
+
+    Uses double-checked locking pattern for thread-safe singleton initialization.
+    """
+
+    _instance: Optional["SessionManager"] = None
+    _lock = Lock()
+    _initialized = False
+
+    def __new__(cls) -> "SessionManager":
+        """
+        Create or return the singleton instance using double-checked locking.
+
+        Returns:
+            The singleton SessionManager instance
+        """
+        # First check without lock (fast path)
+        if cls._instance is None:
+            # Acquire lock for thread safety
+            with cls._lock:
+                # Double-check inside lock
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """
+        Initialize the session manager (only once).
+
+        This method uses an initialization flag to ensure it only
+        runs once, even if __init__ is called multiple times.
+        """
+        # Use class-level lock to ensure thread-safe initialization
+        with self.__class__._lock:
+            if self.__class__._initialized:
+                return
+
+            # Generate session ID once during initialization
+            self._session_id = self._generate_session_id()
+            self._session_start_time = datetime.now(timezone.utc)
+
+            # Mark as initialized
+            self.__class__._initialized = True
+
+            logger.info(
+                f"SessionManager initialized with session ID: {self._session_id}"
+            )
+
+    def _generate_session_id(self) -> str:
+        """
+        Generate or retrieve a session ID.
+
+        Checks environment variables first, then generates a timestamp-based ID.
+
+        Returns:
+            A unique session identifier
+        """
+        # Check environment variables in order of preference
+        env_vars = ["CLAUDE_SESSION_ID", "ANTHROPIC_SESSION_ID", "SESSION_ID"]
+
+        for env_var in env_vars:
+            session_id = os.environ.get(env_var)
+            if session_id:
+                logger.info(f"Using session ID from {env_var}: {session_id}")
+                return session_id
+
+        # Generate timestamp-based session ID
+        session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        logger.info(f"Generated new session ID: {session_id}")
+        return session_id
+
+    def get_session_id(self) -> str:
+        """
+        Get the current session ID.
+
+        Thread-safe method to retrieve the session ID.
+
+        Returns:
+            The current session ID
+        """
+        return self._session_id
+
+    def get_session_start_time(self) -> datetime:
+        """
+        Get the session start time.
+
+        Returns:
+            The datetime when the session was initialized
+        """
+        return self._session_start_time
+
+    def set_session_id(self, session_id: str) -> None:
+        """
+        Override the session ID.
+
+        This should only be used in special circumstances, as it can
+        break the single session ID guarantee.
+
+        Args:
+            session_id: The new session ID to use
+        """
+        with self.__class__._lock:
+            old_id = self._session_id
+            if old_id != session_id:
+                self._session_id = session_id
+                logger.warning(f"Session ID changed from {old_id} to {session_id}")
+            else:
+                logger.debug(f"Session ID already set to {session_id}, no change needed")
+
+    @classmethod
+    def reset(cls) -> None:
+        """
+        Reset the singleton instance (mainly for testing).
+
+        This method should not be used in production code.
+        """
+        with cls._lock:
+            cls._instance = None
+            cls._initialized = False
+            logger.debug("SessionManager singleton reset")
+
+
+# Global accessor function
+_manager: Optional[SessionManager] = None
+
+
+def get_session_manager() -> SessionManager:
+    """
+    Get the global SessionManager instance.
+
+    Thread-safe accessor that ensures a single SessionManager exists.
+
+    Returns:
+        The singleton SessionManager instance
+    """
+    global _manager
+    if _manager is None:
+        _manager = SessionManager()
+    return _manager
+
+
+def get_session_id() -> str:
+    """
+    Convenience function to get the current session ID.
+
+    Returns:
+        The current session ID
+    """
+    return get_session_manager().get_session_id()

{claude_mpm-4.5.6.dist-info → claude_mpm-4.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.5.6
+Version: 4.5.8
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.5.6.dist-info → claude_mpm-4.5.8.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=TZz-l5RDMFBnEZirovU2IQUX14xx_gKKqZQH96mBUT0,6
+claude_mpm/VERSION,sha256=f5wbxv1InvG9hB7daBjMUVwWCbFMx-PRPiN2wYxs6Ns,6
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=cChN3myrAcF3jC-6DvHnBFTEnwlDk-TAsIXPvUZr_yw,5953
@@ -8,14 +8,14 @@ claude_mpm/ticket_wrapper.py,sha256=qe5xY579t7_7fK5nyeAfHN_fr7CXdeOD3jfXEc8-7yo,
 claude_mpm/agents/BASE_AGENT_TEMPLATE.md,sha256=aK9qxS1FRpm_8VaB5GI2I6YA9Wr8dGHuea_txMFe44M,5524
 claude_mpm/agents/BASE_DOCUMENTATION.md,sha256=iGub94w3IRURz2PwT0YrfNegMlEzgZ9mzeWa_WBk1rA,1504
 claude_mpm/agents/BASE_ENGINEER.md,sha256=lXkA6KoCopsRTWS1LOx2s5m6S0hT5UT0s3l5owBo0Hc,7491
-claude_mpm/agents/BASE_OPS.md,sha256=vKtjqJm_mwTVBv07qnAKf56dC06AQLbJEd9f6Wa4ekA,6468
+claude_mpm/agents/BASE_OPS.md,sha256=azAjZTrj77IZIBgZxX2hcjPOQMznV0v6B4ZWNUhAT9g,7636
 claude_mpm/agents/BASE_PM.md,sha256=0n8b45wdRMb9ODLd8tiUu7fBP-UR33Bj0LS-AzHLXNE,3960
 claude_mpm/agents/BASE_QA.md,sha256=tR4RH63IwxidDXlSnSIRRaoGtmVpJp-0_GkQkmFUbjM,1590
 claude_mpm/agents/BASE_RESEARCH.md,sha256=2DZhDd5XxWWtsyNTBIwvtNWBu1JpFy5R5SAZDHh0otU,1690
 claude_mpm/agents/INSTRUCTIONS_OLD_DEPRECATED.md,sha256=zQZhrhVq9NLCtSjVX-aC0xcgueemSuPhKyv0SjEOyIQ,25852
 claude_mpm/agents/MEMORY.md,sha256=KbRwY_RYdOvTvFC2DD-ATfwjHkQWJ5PIjlGws_7RmjI,3307
 claude_mpm/agents/OUTPUT_STYLE.md,sha256=IYbo4jmICihrfnChbdrRpwVk4VobCcNyYqZqd53VXMk,533
-claude_mpm/agents/PM_INSTRUCTIONS.md,sha256=DWkWaJePOmDVE6rieIRqaQTasEppGcPaozHkeezQgRo,29048
+claude_mpm/agents/PM_INSTRUCTIONS.md,sha256=NAT35pAaM0VxgtMtspDh2Nz4K_OmTTNZ0CvODevwwws,30856
 claude_mpm/agents/WORKFLOW.md,sha256=m4hjQNX8tZKNlyVPjvGJJXc-UG3yzkscmu9Nwfcddsw,2373
 claude_mpm/agents/__init__.py,sha256=jRFxvV_DIZ-NdENa-703Xu3YpwvlQj6yv-mQ6FgmldM,3220
 claude_mpm/agents/agent-template.yaml,sha256=mRlz5Yd0SmknTeoJWgFkZXzEF5T7OmGBJGs2-KPT93k,1969
@@ -38,7 +38,7 @@ claude_mpm/agents/templates/documentation.json,sha256=Hp9GADw0Wttmxe2pxTCg40DT1A
 claude_mpm/agents/templates/engineer.json,sha256=tAWKqt35OyL0RUQgTSeX9nVtcjF94ND-WbflXStAXHA,8222
 claude_mpm/agents/templates/gcp_ops_agent.json,sha256=v2exIGCzPLBDu5M4CCxZ1k3EQfrV0jc6T9C2ecPjScY,10812
 claude_mpm/agents/templates/imagemagick.json,sha256=6Zy4W_q6BYkJxd_KqDT2B3GBkwhn7VKT9ZVj-O_tj0Q,17747
-claude_mpm/agents/templates/local_ops_agent.json,sha256=50i0Ic2zkxR19VRw8kAadkdR3-sq03SASj1e8TgLIZo,8203
+claude_mpm/agents/templates/local_ops_agent.json,sha256=h92JVFa3pYMRvkw2yEVxfTuyUQ2PFhgaWw_7uD2CmJ0,9947
 claude_mpm/agents/templates/memory_manager.json,sha256=b6bTMLFShY4-884pgjc6wsfLICcVx17ZrRj7y-NH61w,12613
 claude_mpm/agents/templates/nextjs_engineer.json,sha256=Y2NUxJ3D6FFkDdk83kTqbJ70IZKAVJZkePbyEX_hESo,18786
 claude_mpm/agents/templates/ops.json,sha256=zp1uBfxdp7Atja0oLcNr8TAv-CQuK4mAnbfnLQMFIF4,10904
@@ -403,23 +403,24 @@ claude_mpm/scripts/socketio_daemon.py,sha256=I1n0ny6UZTQWKN-_ZiNKK37jJTRgRESyHDA
 claude_mpm/scripts/start_activity_logging.py,sha256=1G9bFYiBSkpxSRXyKht73nL5gH-4zwukLutWWKAipGg,2869
 claude_mpm/services/__init__.py,sha256=X10comSYoSvoi4jaz9a7ztqcYhCZMX7QmX7nwHGJjCM,7495
 claude_mpm/services/agent_capabilities_service.py,sha256=8-LA1JuTF9IZRBT0AvU4HF9OBMCyySTOZGNuX17T6JM,10776
-claude_mpm/services/async_session_logger.py,sha256=X_BTBRXwLThgFb8Vtkg0PsA2HN2-1RH6wqdBGxfQSgM,23013
-claude_mpm/services/claude_session_logger.py,sha256=QLPz46shI6m0gmfxr7vn_mMXNjhYMYd3PDfhpIOQjWo,10882
+claude_mpm/services/async_session_logger.py,sha256=zheHivwLakwIbQSJ5geMJtB9RU9IOxZjQJoxHsQuAy4,23880
+claude_mpm/services/claude_session_logger.py,sha256=zKw5X1rGv7LxTEw7xLQujv1GTV9cCRPiW7paHLOWcYU,11157
 claude_mpm/services/command_deployment_service.py,sha256=FxrHWuhvEaYL6PmjCN7Y0TlGWWIDHkzm_0UwvqI2C3A,6132
 claude_mpm/services/command_handler_service.py,sha256=LdKnujKUgrCYrvKvmCXaUMk7JGFJsyNeiKnDFdR8ox8,7031
 claude_mpm/services/event_aggregator.py,sha256=DDcehIZVpiEDzs9o18gDZyvjMBHCq2H8HF4h0ofG9d4,20250
 claude_mpm/services/exceptions.py,sha256=5lVZETr_6-xk0ItH7BTfYUiX5RlckS1e8ah_UalYG9c,26475
 claude_mpm/services/hook_installer_service.py,sha256=z3kKeriEY1Y9bFesuGlHBxhCtc0Wzd3Zv02k2_rEyGo,19727
 claude_mpm/services/hook_service.py,sha256=rZnMn_4qxX5g9KAn0IQdoG50WmySNfsTmfG0XHuRHXk,15737
-claude_mpm/services/mcp_config_manager.py,sha256=hCcc0PFrWSORyPiDONBDQ4TDzrLF1dqXcWbglUoN3po,54077
+claude_mpm/services/mcp_config_manager.py,sha256=2uukgzVImMQroNlwKgWhxDLi0UzJ0CP4L_dSK3bFcy4,62643
 claude_mpm/services/mcp_service_verifier.py,sha256=yxybULGAjde3oMqwQ92BiOthlAJKfS_ierPkShFoDHE,25655
 claude_mpm/services/memory_hook_service.py,sha256=pRlTClkRcw30Jhwbha4BC8IMdzKZxF8aWqf52JlntgY,11600
 claude_mpm/services/monitor_build_service.py,sha256=8gWR9CaqgXdG6-OjOFXGpk28GCcJTlHhojkUYnMCebI,12160
 claude_mpm/services/port_manager.py,sha256=CYqLh8Ss_-aoYEXV3G6uZkGexpsRK_XTBL0bV4P3tSI,22838
 claude_mpm/services/recovery_manager.py,sha256=ptUYsguF6oKWnJnzPRSBuzUFVDXIcvsS3svT6MBTqCQ,25686
-claude_mpm/services/response_tracker.py,sha256=agm7wDCfXdgC2apLKSq6eiPy79OKPMc1wfKRnz4CdmU,9216
+claude_mpm/services/response_tracker.py,sha256=KsmQOhRMMOx9_bqmyCY0cjknnT9ncaj4D1i9bNpf8fc,9574
 claude_mpm/services/runner_configuration_service.py,sha256=Qs84yrZfQv-DC0I2Xah1Qt9eunH4gS7LNMZ0mmymcqA,21311
 claude_mpm/services/session_management_service.py,sha256=DdFeL_oPO-FGKyTjaDkAnyzZAFckmdT54U5z2QC4bn8,10061
+claude_mpm/services/session_manager.py,sha256=V0a0vpBNRyDz67Ku27agp-nsOU_5LTD2lvEpGPAnWAw,5106
 claude_mpm/services/socketio_client_manager.py,sha256=cZjIsnoi2VPXFA-5pNhoz5Vv3qv0iuSTy510TgAJU4U,18179
 claude_mpm/services/socketio_server.py,sha256=yE14_4pHERXBC5L1WQCpIBHuy0tpklsUY_icyl-nLkg,3033
 claude_mpm/services/subprocess_launcher_service.py,sha256=b8FeO0kh6AblWqnFX4XtSxEw93tENCczVvK0OjbYvpk,10999
@@ -776,9 +777,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=D0izRT8anjiUb_JG72zlJR_JAw1cDkb7kalN
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=Nm2WmcbCb0EwOG4nFcikc3wVdiiAfjGBBI3YoR6ainQ,20915
 claude_mpm/validation/frontmatter_validator.py,sha256=IDBOCBweO6umydSnUJjBh81sKk3cy9hRFYm61DCiXbI,7020
-claude_mpm-4.5.6.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.5.6.dist-info/METADATA,sha256=8gYiFkHq_U1xhjhFPxVv4_mvuy08lsjaWQRN7-oCx_c,17517
-claude_mpm-4.5.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.5.6.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
-claude_mpm-4.5.6.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.5.6.dist-info/RECORD,,
+claude_mpm-4.5.8.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.5.8.dist-info/METADATA,sha256=INLLT4P_neAeA3jZvG2hn9x246XElymx0iF3yt5-Hgs,17517
+claude_mpm-4.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.5.8.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
+claude_mpm-4.5.8.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.5.8.dist-info/RECORD,,