claude-mpm 4.4.9__py3-none-any.whl → 4.4.11__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.4.9
+4.4.11

claude_mpm/agents/PM_INSTRUCTIONS.md

@@ -67,12 +67,45 @@
 ✓ TodoWrite - For tracking delegated work
 ✓ Read - ONLY for reading ONE file maximum (more = violation)
 ✓ Bash - ONLY for `ls`, `pwd` (NOT for investigation)
+✓ SlashCommand - For executing Claude MPM commands (see MPM Commands section below)
 ✓ mcp__mcp-vector-search__* - For quick code search BEFORE delegation (helps better task definition)
 ❌ Grep/Glob - FORBIDDEN for PM (delegate to Research for deep investigation)
 ❌ WebSearch/WebFetch - FORBIDDEN for PM (delegate to Research)
 
 **VIOLATION TRACKING ACTIVE**: Each violation logged, escalated, and reported.
 
+## CLAUDE MPM SLASH COMMANDS
+
+**IMPORTANT**: Claude MPM has special slash commands that are NOT file paths. These are framework commands that must be executed using the SlashCommand tool.
+
+### Common MPM Commands
+These commands start with `/mpm-` and are Claude MPM system commands:
+- `/mpm-doctor` - Run system diagnostics (use SlashCommand tool)
+- `/mpm-init` - Initialize MPM project (use SlashCommand tool)
+- `/mpm-status` - Check MPM service status (use SlashCommand tool)
+- `/mpm-monitor` - Control monitoring services (use SlashCommand tool)
+- `/mpm-browser-monitor` - Control browser monitoring (use SlashCommand tool)
+
+### How to Execute MPM Commands
+✅ **CORRECT**: Use SlashCommand tool
+```
+SlashCommand: command="/mpm-doctor"
+SlashCommand: command="/mpm-monitor start"
+```
+
+❌ **WRONG**: Treating as file paths or bash commands
+```
+Bash: ./mpm-doctor  # WRONG - not a file
+Bash: /mpm-doctor   # WRONG - not a file path
+Read: /mpm-doctor   # WRONG - not a file to read
+```
+
+### Recognition Rules
+- If user mentions `/mpm-*` → It's a Claude MPM command → Use SlashCommand
+- If command starts with slash and is NOT a file path → Check if it's an MPM command
+- MPM commands are system operations, NOT files or scripts
+- Always use SlashCommand tool for these operations
+
 ## NO ASSERTION WITHOUT VERIFICATION RULE
 
 **CRITICAL**: PM MUST NEVER make claims without evidence from agents.
@@ -139,6 +172,7 @@
 | "what is", "how does", "where is" | "I'll have Research investigate" | Research |
 | "error", "bug", "issue" | "I'll have QA reproduce this" | QA |
 | "slow", "performance" | "I'll have QA benchmark this" | QA |
+| "/mpm-doctor", "/mpm-status", etc | "I'll run the MPM command" | Use SlashCommand tool (NOT bash) |
 | ANY question about code | "I'll have Research examine this" | Research |
 
 ### 🔴 CIRCUIT BREAKER - IMPLEMENTATION DETECTION 🔴

claude_mpm/scripts/mpm_doctor.py

@@ -51,9 +51,9 @@ def run_diagnostics(
         - warning_count: int - number of warnings found
         - message: str - optional error message if failed
     """
-from claude_mpm.core.logging_utils import get_logger
+    from claude_mpm.core.logging_utils import get_logger
 
-logger = get_logger(__name__)
+    logger = get_logger(__name__)
 
     # Create diagnostic runner
     runner = DiagnosticRunner(verbose=verbose, fix=fix)

claude_mpm/services/diagnostics/checks/mcp_services_check.py

@@ -84,6 +84,33 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             sub_results = []
             services_status = {}
 
+            # Use MCPConfigManager to detect and fix corrupted installations
+            from claude_mpm.services.mcp_config_manager import MCPConfigManager
+            mcp_manager = MCPConfigManager()
+
+            # Run comprehensive fix for all MCP service issues
+            fix_success, fix_message = mcp_manager.fix_mcp_service_issues()
+            if fix_message and fix_message != "All MCP services are functioning correctly":
+                # Create diagnostic result for the fixes
+                fix_result = DiagnosticResult(
+                    category="MCP Service Fixes",
+                    status=DiagnosticStatus.OK if fix_success else DiagnosticStatus.WARNING,
+                    message=fix_message,
+                    details={"auto_fix_applied": True}
+                )
+                sub_results.append(fix_result)
+
+            # Also ensure configurations are updated for all projects
+            config_success, config_message = mcp_manager.ensure_mcp_services_configured()
+            if config_message and config_message != "All MCP services already configured correctly":
+                config_result = DiagnosticResult(
+                    category="MCP Configuration Update",
+                    status=DiagnosticStatus.OK if config_success else DiagnosticStatus.WARNING,
+                    message=config_message,
+                    details={"auto_config_applied": True}
+                )
+                sub_results.append(config_result)
+
             # Check for kuzu-memory configuration issues and offer auto-fix
             kuzu_config_result = self._check_and_fix_kuzu_memory_config()
             if kuzu_config_result:

claude_mpm/services/mcp_config_manager.py

@@ -46,24 +46,25 @@ class MCPConfigManager:
     STATIC_MCP_CONFIGS = {
         "kuzu-memory": {
             "type": "stdio",
-            "command": "pipx",
-            "args": ["run", "kuzu-memory", "mcp", "serve"]
+            "command": "kuzu-memory",  # Use direct binary, will be resolved to full path
+            "args": ["mcp", "serve"]  # v1.1.0+ uses 'mcp serve' command
         },
         "mcp-ticketer": {
             "type": "stdio",
-            "command": "pipx",
-            "args": ["run", "mcp-ticketer", "mcp"]
+            "command": "mcp-ticketer",  # Use direct binary to preserve injected dependencies
+            "args": ["mcp"]
         },
         "mcp-browser": {
             "type": "stdio",
-            "command": "pipx",
-            "args": ["run", "mcp-browser", "mcp"],
+            "command": "mcp-browser",  # Use direct binary
+            "args": ["mcp"],
             "env": {"MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")}
         },
         "mcp-vector-search": {
             "type": "stdio",
-            "command": "pipx",
-            "args": ["run", "mcp-vector-search", "-m", "mcp_vector_search.mcp.server", "{project_root}"],
+            # Use pipx venv's Python directly for module execution
+            "command": str(Path.home() / ".local" / "pipx" / "venvs" / "mcp-vector-search" / "bin" / "python"),
+            "args": ["-m", "mcp_vector_search.mcp.server", "{project_root}"],
             "env": {}
         }
     }
@@ -222,12 +223,95 @@ class MCPConfigManager:
 
         return None
 
-    def get_static_service_config(self, service_name: str) -> Optional[Dict]:
+    def test_service_command(self, service_name: str, config: Dict) -> bool:
+        """
+        Test if a service configuration actually works.
+
+        Args:
+            service_name: Name of the MCP service
+            config: Service configuration to test
+
+        Returns:
+            True if service responds correctly, False otherwise
+        """
+        try:
+            import shutil
+
+            # Build command - handle pipx PATH issues
+            command = config["command"]
+
+            # If command is pipx and not found, try common paths
+            if command == "pipx":
+                pipx_path = shutil.which("pipx")
+                if not pipx_path:
+                    # Try common pipx locations
+                    for possible_path in [
+                        "/opt/homebrew/bin/pipx",
+                        "/usr/local/bin/pipx",
+                        str(Path.home() / ".local" / "bin" / "pipx"),
+                    ]:
+                        if Path(possible_path).exists():
+                            command = possible_path
+                            break
+                else:
+                    command = pipx_path
+
+            cmd = [command]
+
+            # Add test args (--help or --version)
+            if "args" in config:
+                # For MCP services, test with --help after the subcommand
+                test_args = config["args"].copy()
+                # Replace project root placeholder for testing
+                test_args = [
+                    arg.replace("{project_root}", str(self.project_root)) if "{project_root}" in arg else arg
+                    for arg in test_args
+                ]
+
+                # Add --help at the end
+                if service_name == "mcp-vector-search":
+                    # For Python module invocation, just test if Python can import the module
+                    cmd.extend(test_args[:2])  # Just python -m module_name
+                    cmd.extend(["--help"])
+                else:
+                    cmd.extend(test_args)
+                    cmd.append("--help")
+            else:
+                cmd.append("--help")
+
+            # Run test command with timeout
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+                env=config.get("env", {})
+            )
+
+            # Check if command executed (exit code 0 or 1 for help)
+            if result.returncode in [0, 1]:
+                # Additional check for import errors in stderr
+                if "ModuleNotFoundError" in result.stderr or "ImportError" in result.stderr:
+                    self.logger.debug(f"Service {service_name} has import errors")
+                    return False
+                return True
+
+        except subprocess.TimeoutExpired:
+            # Timeout might mean the service started successfully and is waiting for input
+            return True
+        except Exception as e:
+            self.logger.debug(f"Error testing {service_name}: {e}")
+
+        return False
+
+    def get_static_service_config(self, service_name: str, project_path: Optional[str] = None) -> Optional[Dict]:
         """
         Get the static, known-good configuration for an MCP service.
 
         Args:
             service_name: Name of the MCP service
+            project_path: Optional project path to use (defaults to current project)
 
         Returns:
             Static service configuration dict or None if service not known
@@ -236,11 +320,79 @@ class MCPConfigManager:
             return None
 
         config = self.STATIC_MCP_CONFIGS[service_name].copy()
+        import shutil
+
+        # Resolve service binary commands to full paths
+        if service_name in ["kuzu-memory", "mcp-ticketer", "mcp-browser"]:
+            # Try to find the full path of the binary
+            binary_name = config["command"]
+            binary_path = shutil.which(binary_name)
+
+            if not binary_path:
+                # Try common installation locations
+                possible_paths = [
+                    f"/opt/homebrew/bin/{binary_name}",
+                    f"/usr/local/bin/{binary_name}",
+                    str(Path.home() / ".local" / "bin" / binary_name),
+                ]
+                for path in possible_paths:
+                    if Path(path).exists():
+                        binary_path = path
+                        break
+
+            if binary_path:
+                config["command"] = binary_path
+            # If still not found, keep the binary name and hope it's in PATH
+
+        # Resolve pipx command to full path if needed
+        elif config.get("command") == "pipx":
+            pipx_path = shutil.which("pipx")
+            if not pipx_path:
+                # Try common pipx locations
+                for possible_path in [
+                    "/opt/homebrew/bin/pipx",
+                    "/usr/local/bin/pipx",
+                    str(Path.home() / ".local" / "bin" / "pipx"),
+                ]:
+                    if Path(possible_path).exists():
+                        pipx_path = possible_path
+                        break
+            if pipx_path:
+                config["command"] = pipx_path
+            else:
+                # Keep as "pipx" and hope it's in PATH when executed
+                config["command"] = "pipx"
 
-        # Special handling for mcp-vector-search: replace {project_root} placeholder
+        # Handle user-specific paths for mcp-vector-search
         if service_name == "mcp-vector-search":
+            # Get the correct pipx venv path for the current user
+            home = Path.home()
+            python_path = home / ".local" / "pipx" / "venvs" / "mcp-vector-search" / "bin" / "python"
+
+            # Check if the Python interpreter exists, if not fallback to pipx run
+            if python_path.exists():
+                config["command"] = str(python_path)
+            else:
+                # Fallback to pipx run method
+                import shutil
+                pipx_path = shutil.which("pipx")
+                if not pipx_path:
+                    # Try common pipx locations
+                    for possible_path in [
+                        "/opt/homebrew/bin/pipx",
+                        "/usr/local/bin/pipx",
+                        str(Path.home() / ".local" / "bin" / "pipx"),
+                    ]:
+                        if Path(possible_path).exists():
+                            pipx_path = possible_path
+                            break
+                config["command"] = pipx_path if pipx_path else "pipx"
+                config["args"] = ["run", "--spec", "mcp-vector-search", "python"] + config["args"]
+
+            # Use provided project path or current project
+            project_root = project_path if project_path else str(self.project_root)
             config["args"] = [
-                arg.replace("{project_root}", str(self.project_root)) if "{project_root}" in arg else arg
+                arg.replace("{project_root}", project_root) if "{project_root}" in arg else arg
                 for arg in config["args"]
             ]
 
@@ -262,7 +414,12 @@ class MCPConfigManager:
         # First try to get static configuration
         static_config = self.get_static_service_config(service_name)
         if static_config:
-            return static_config
+            # Validate that the static config actually works
+            if self.test_service_command(service_name, static_config):
+                self.logger.debug(f"Static config for {service_name} validated successfully")
+                return static_config
+            else:
+                self.logger.warning(f"Static config for {service_name} failed validation, trying fallback")
 
         # Fall back to detection-based configuration for unknown services
         import shutil
@@ -460,11 +617,10 @@ class MCPConfigManager:
             claude_config["projects"] = {}
             updated = True
 
-        # Check and fix mcp-ticketer dependencies ONCE before processing projects
-        # This avoids running the same pipx inject command 100+ times
-        mcp_ticketer_fixed = False
-        if "mcp-ticketer" in self.PIPX_SERVICES:
-            mcp_ticketer_fixed = self._check_and_fix_mcp_ticketer_dependencies()
+        # Fix any corrupted MCP service installations first
+        fix_success, fix_message = self.fix_mcp_service_issues()
+        if not fix_success:
+            self.logger.warning(f"Some MCP services could not be fixed: {fix_message}")
 
         # Process ALL projects in the config, not just current one
         projects_to_update = list(claude_config.get("projects", {}).keys())
@@ -499,16 +655,12 @@ class MCPConfigManager:
 
             # Check and fix each service configuration
             for service_name in self.PIPX_SERVICES:
-                # Get the correct static configuration
-                correct_config = self.STATIC_MCP_CONFIGS[service_name].copy()
+                # Get the correct static configuration with project-specific paths
+                correct_config = self.get_static_service_config(service_name, project_key)
 
-                # Special handling for mcp-vector-search: replace {project_root} placeholder
-                if service_name == "mcp-vector-search":
-                    # Use the project key as the project root for each project
-                    correct_config["args"] = [
-                        arg.replace("{project_root}", project_key) if "{project_root}" in arg else arg
-                        for arg in correct_config["args"]
-                    ]
+                if not correct_config:
+                    self.logger.warning(f"No static config available for {service_name}")
+                    continue
 
                 # Check if service exists and has correct configuration
                 existing_config = project_config["mcpServers"].get(service_name)
@@ -837,6 +989,207 @@ class MCPConfigManager:
             self.logger.debug(f"Could not check/fix mcp-ticketer dependencies: {e}")
             return False
 
+    def fix_mcp_service_issues(self) -> Tuple[bool, str]:
+        """
+        Detect and fix corrupted MCP service installations.
+
+        This method:
+        1. Tests each MCP service for import/execution errors
+        2. Automatically reinstalls corrupted services
+        3. Fixes missing dependencies (like mcp-ticketer's gql)
+        4. Validates fixes worked
+
+        Returns:
+            Tuple of (success, message)
+        """
+        self.logger.info("🔍 Checking MCP services for issues...")
+
+        services_to_fix = []
+        fixed_services = []
+        failed_services = []
+
+        # Check each service for issues
+        for service_name in self.PIPX_SERVICES:
+            issue_type = self._detect_service_issue(service_name)
+            if issue_type:
+                services_to_fix.append((service_name, issue_type))
+                self.logger.debug(f"Found issue with {service_name}: {issue_type}")
+
+        if not services_to_fix:
+            return True, "All MCP services are functioning correctly"
+
+        # Fix each problematic service
+        for service_name, issue_type in services_to_fix:
+            self.logger.info(f"🔧 Fixing {service_name}: {issue_type}")
+
+            if issue_type == "not_installed":
+                # Install the service
+                success, method = self._install_service_with_fallback(service_name)
+                if success:
+                    fixed_services.append(f"{service_name} (installed via {method})")
+                else:
+                    failed_services.append(f"{service_name} (installation failed)")
+
+            elif issue_type == "import_error":
+                # Reinstall to fix corrupted installation
+                self.logger.info(f"  Reinstalling {service_name} to fix import errors...")
+                success = self._reinstall_service(service_name)
+                if success:
+                    # Special handling for mcp-ticketer - inject missing gql dependency
+                    if service_name == "mcp-ticketer":
+                        self._check_and_fix_mcp_ticketer_dependencies()
+                    fixed_services.append(f"{service_name} (reinstalled)")
+                else:
+                    failed_services.append(f"{service_name} (reinstall failed)")
+
+            elif issue_type == "missing_dependency":
+                # Fix missing dependencies
+                if service_name == "mcp-ticketer":
+                    if self._check_and_fix_mcp_ticketer_dependencies():
+                        fixed_services.append(f"{service_name} (dependency fixed)")
+                    else:
+                        failed_services.append(f"{service_name} (dependency fix failed)")
+                else:
+                    failed_services.append(f"{service_name} (unknown dependency issue)")
+
+            elif issue_type == "path_issue":
+                # Path issues are handled by config updates
+                self.logger.info(f"  Path issue for {service_name} will be fixed by config update")
+                fixed_services.append(f"{service_name} (config updated)")
+
+        # Build result message
+        messages = []
+        if fixed_services:
+            messages.append(f"✅ Fixed: {', '.join(fixed_services)}")
+        if failed_services:
+            messages.append(f"❌ Failed: {', '.join(failed_services)}")
+
+        # Return success if at least some services were fixed
+        success = len(fixed_services) > 0 or len(failed_services) == 0
+        message = " | ".join(messages) if messages else "No services needed fixing"
+
+        # Provide manual fix instructions if auto-fix failed
+        if failed_services:
+            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}"
+
+        return success, message
+
+    def _detect_service_issue(self, service_name: str) -> Optional[str]:
+        """
+        Detect what type of issue a service has.
+
+        Returns:
+            Issue type: 'not_installed', 'import_error', 'missing_dependency', 'path_issue', or None
+        """
+        import shutil
+
+        # First check if pipx is available
+        if not shutil.which("pipx"):
+            return "not_installed"  # Can't use pipx services without pipx
+
+        # Try to run the service with --help to detect issues
+        try:
+            # Test with pipx run
+            result = subprocess.run(
+                ["pipx", "run", service_name, "--help"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False
+            )
+
+            # Check for specific error patterns
+            stderr_lower = result.stderr.lower()
+            stdout_lower = result.stdout.lower()
+            combined_output = stderr_lower + stdout_lower
+
+            # Not installed
+            if "no apps associated" in combined_output or "not found" in combined_output:
+                return "not_installed"
+
+            # Import errors (like mcp-ticketer's corrupted state)
+            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]:
+                return None  # Service is working
+
+            # Unknown issue
+            if result.returncode not in [0, 1]:
+                return "unknown_error"
+
+        except subprocess.TimeoutExpired:
+            # Timeout might mean service is actually working but waiting for input
+            return None
+        except Exception as e:
+            self.logger.debug(f"Error detecting issue for {service_name}: {e}")
+            return "unknown_error"
+
+        return None
+
+    def _reinstall_service(self, service_name: str) -> bool:
+        """
+        Reinstall a corrupted MCP service.
+
+        Args:
+            service_name: Name of the service to reinstall
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            self.logger.debug(f"Uninstalling {service_name}...")
+
+            # First uninstall the corrupted version
+            uninstall_result = subprocess.run(
+                ["pipx", "uninstall", service_name],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False
+            )
+
+            # Don't check return code - uninstall might fail if partially corrupted
+            self.logger.debug(f"Uninstall result: {uninstall_result.returncode}")
+
+            # Now reinstall
+            self.logger.debug(f"Installing fresh {service_name}...")
+            install_result = subprocess.run(
+                ["pipx", "install", service_name],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False
+            )
+
+            if install_result.returncode == 0:
+                # Verify the reinstall worked
+                issue = self._detect_service_issue(service_name)
+                if issue is None:
+                    self.logger.info(f"✅ Successfully reinstalled {service_name}")
+                    return True
+                else:
+                    self.logger.warning(f"Reinstalled {service_name} but still has issue: {issue}")
+                    return False
+            else:
+                self.logger.error(f"Failed to reinstall {service_name}: {install_result.stderr}")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"Error reinstalling {service_name}: {e}")
+            return False
+
     def _verify_service_installed(self, service_name: str, method: str) -> bool:
         """
         Verify that a service was successfully installed and is functional.
@@ -912,3 +1265,26 @@ class MCPConfigManager:
             self.logger.debug(f"Verification error for {service_name}: {e}")
 
         return False
+
+    def _get_fallback_config(self, service_name: str, project_path: str) -> Optional[Dict]:
+        """
+        Get a fallback configuration for a service if the primary config fails.
+
+        Args:
+            service_name: Name of the MCP service
+            project_path: Project path to use
+
+        Returns:
+            Fallback configuration or None
+        """
+        # Special fallback for mcp-vector-search using pipx run
+        if service_name == "mcp-vector-search":
+            return {
+                "type": "stdio",
+                "command": "pipx",
+                "args": ["run", "--spec", "mcp-vector-search", "python", "-m", "mcp_vector_search.mcp.server", project_path],
+                "env": {}
+            }
+
+        # For other services, try pipx run
+        return None

{claude_mpm-4.4.9.dist-info → claude_mpm-4.4.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.4.9
+Version: 4.4.11
 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.4.9.dist-info → claude_mpm-4.4.11.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=k8-5xMoy2UlbzZa4MVGVy1j0Ym4rIg_47OvMJE5eNKg,6
+claude_mpm/VERSION,sha256=wsjLXi1090mCdeXOCOer2wlQEWPDV51wB6VBJvhb3hw,7
 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
@@ -15,7 +15,7 @@ claude_mpm/agents/BASE_RESEARCH.md,sha256=2DZhDd5XxWWtsyNTBIwvtNWBu1JpFy5R5SAZDH
 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=wTjmrnJjGo3bFvQQcj1VJ1wEFgYePaOe3NFGa_1vf50,25963
+claude_mpm/agents/PM_INSTRUCTIONS.md,sha256=bdf38c2PS0qrXg1wq2lFDKAzkCmUQs1L8uTVwJk_TlY,27438
 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
@@ -398,7 +398,7 @@ claude_mpm/scripts/claude-hook-handler.sh,sha256=xe6dKubrjK1JDO0SJdc1-tA6C7YSb5Y
 claude_mpm/scripts/launch_monitor.py,sha256=Q7hN4Wurw45veLWPSXk0WfvkKxQ1Snz7TjZsV_pNWQc,2418
 claude_mpm/scripts/mcp_server.py,sha256=_i9ydtI7AcO-Eb7gzbIDbcJY4PKRQRYNobB8eMailI4,2259
 claude_mpm/scripts/mcp_wrapper.py,sha256=PvfHJShcsQHGJZD-RN3RnwLOzemAKYZ2kW_QfTkGzkk,1105
-claude_mpm/scripts/mpm_doctor.py,sha256=mqvz1ePtrzzaP6S2oG2teJQx5mq3QM4HXgNKmEXVau8,8814
+claude_mpm/scripts/mpm_doctor.py,sha256=98vBiTIB4xpaSgOvTP9N3EU22V2Odxd9DivhQizG0VM,8822
 claude_mpm/scripts/socketio_daemon.py,sha256=I1n0ny6UZTQWKN-_ZiNKK37jJTRgRESyHDAVvXWK33M,6038
 claude_mpm/scripts/start_activity_logging.py,sha256=1G9bFYiBSkpxSRXyKht73nL5gH-4zwukLutWWKAipGg,2869
 claude_mpm/services/__init__.py,sha256=X10comSYoSvoi4jaz9a7ztqcYhCZMX7QmX7nwHGJjCM,7495
@@ -411,7 +411,7 @@ claude_mpm/services/event_aggregator.py,sha256=DDcehIZVpiEDzs9o18gDZyvjMBHCq2H8H
 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=iEBnl9rPFR-PccOol8ZdufyCvhZvVN47wYtTteQVpBY,35112
+claude_mpm/services/mcp_config_manager.py,sha256=Rsbk9Ygq7tJWqZI67VnYWSW30_9ptmLjyX7xf-rJcho,50465
 claude_mpm/services/mcp_service_verifier.py,sha256=ngiegCngX18AFehfyJdvqQAvscoIBvFN_DeOoGTjxj0,25164
 claude_mpm/services/memory_hook_service.py,sha256=pRlTClkRcw30Jhwbha4BC8IMdzKZxF8aWqf52JlntgY,11600
 claude_mpm/services/monitor_build_service.py,sha256=8gWR9CaqgXdG6-OjOFXGpk28GCcJTlHhojkUYnMCebI,12160
@@ -560,7 +560,7 @@ claude_mpm/services/diagnostics/checks/filesystem_check.py,sha256=V5HoHDYlSuoK2l
 claude_mpm/services/diagnostics/checks/installation_check.py,sha256=WoTt15R8Wg-6k2JZFAtmffFuih1AIyCX71QOHEFH-Ro,19562
 claude_mpm/services/diagnostics/checks/instructions_check.py,sha256=VbgBorl0RpFvxKQ_SC1gibTmGSiXaKSp-vVZt6hbH1g,16290
 claude_mpm/services/diagnostics/checks/mcp_check.py,sha256=SftuhP70abopyMD8GlLA_K3XHEYnBAeITggUQI0cYP4,12173
-claude_mpm/services/diagnostics/checks/mcp_services_check.py,sha256=SrHdpRbEc62e7mkfC_m8aGFtQIkhNOmiiCQZ78MME98,40800
+claude_mpm/services/diagnostics/checks/mcp_services_check.py,sha256=ESE5ITzNjkCWWKMQdQoTBDLK8pZQ9MJY4x-E_nVuRww,42278
 claude_mpm/services/diagnostics/checks/monitor_check.py,sha256=NUx5G1yjHWlukZmwhUz4o8STRWgsQEx01YjIMReNC0A,10096
 claude_mpm/services/diagnostics/checks/startup_log_check.py,sha256=DrXdml2rHvmhFBdb_sntE3xmwaP_DZIKjdVbCn8Dy7E,12258
 claude_mpm/services/event_bus/__init__.py,sha256=ETCo4a6puIeyVWAv55uCDjjhzNyUwbVAHEcAVkVapx8,688
@@ -773,9 +773,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.4.9.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.4.9.dist-info/METADATA,sha256=RSN3ddmTCsiu9uTUoaSFYFeB7O56BR7awyIOpLkSVsA,17517
-claude_mpm-4.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.4.9.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.4.9.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.4.9.dist-info/RECORD,,
+claude_mpm-4.4.11.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.4.11.dist-info/METADATA,sha256=GfGvZ-4PutVAH_2DAeQ7S5E-KubU1gqXSwbqnB2yh2Y,17518
+claude_mpm-4.4.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.4.11.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
+claude_mpm-4.4.11.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.4.11.dist-info/RECORD,,

{claude_mpm-4.4.9.dist-info → claude_mpm-4.4.11.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 claude-mpm = claude_mpm.cli:main
+claude-mpm-doctor = claude_mpm.scripts.mpm_doctor:main
 claude-mpm-mcp = claude_mpm.services.mcp_gateway.server.stdio_server:main_sync
 claude-mpm-mcp-wrapper = claude_mpm.scripts.mcp_wrapper:entry_point
 claude-mpm-monitor = claude_mpm.scripts.launch_monitor:main