claude-mpm 4.7.9__py3-none-any.whl → 4.7.11__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.7.9
+4.7.11

claude_mpm/cli/__init__.py

@@ -36,6 +36,7 @@ from .commands import (  # run_guarded_session is imported lazily to avoid loadi
 )
 from .commands.analyze_code import manage_analyze_code
 from .commands.dashboard import manage_dashboard
+from .commands.upgrade import upgrade
 from .parser import create_parser, preprocess_args
 from .utils import ensure_directories, setup_logging
 
@@ -232,6 +233,9 @@ def main(argv: Optional[list] = None):
         # Re-enabled: MCP pre-warming is safe with subprocess daemon (v4.2.40)
         # The subprocess approach avoids fork() issues entirely
         _verify_mcp_gateway_startup()
+
+        # Check for updates (non-blocking, async)
+        _check_for_updates_async()
     else:
         # Still need directories for configure command to work
         ensure_directories()
@@ -544,6 +548,83 @@ def _verify_mcp_gateway_startup():
         # Continue execution - MCP gateway issues shouldn't block startup
 
 
+def _check_for_updates_async():
+    """
+    Check for updates in background thread (non-blocking).
+
+    WHY: Users should be notified of new versions and have an easy way to upgrade
+    without manually checking PyPI/npm. This runs asynchronously on startup to avoid
+    blocking the CLI.
+
+    DESIGN DECISION: This is non-blocking and non-critical - failures are logged
+    but don't prevent startup. Only runs for pip/pipx/npm installations, skips
+    editable/development installations.
+    """
+
+    def run_update_check():
+        """Inner function to run in background thread."""
+        loop = None
+        try:
+            import asyncio
+
+            from ..core.logger import get_logger
+            from ..services.self_upgrade_service import SelfUpgradeService
+
+            logger = get_logger("upgrade_check")
+
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            # Create upgrade service and check for updates
+            upgrade_service = SelfUpgradeService()
+
+            # Skip for editable installs (development mode)
+            from ..services.self_upgrade_service import InstallationMethod
+
+            if upgrade_service.installation_method == InstallationMethod.EDITABLE:
+                logger.debug("Skipping version check for editable installation")
+                return
+
+            # Check and prompt for upgrade if available (non-blocking)
+            loop.run_until_complete(upgrade_service.check_and_prompt_on_startup())
+
+        except Exception as e:
+            # Non-critical - log but don't fail startup
+            try:
+                from ..core.logger import get_logger
+
+                logger = get_logger("upgrade_check")
+                logger.debug(f"Update check failed (non-critical): {e}")
+            except Exception:
+                pass  # Avoid any errors in error handling
+        finally:
+            # Properly clean up event loop
+            if loop is not None:
+                try:
+                    # Cancel all running tasks
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    # Wait for tasks to complete cancellation
+                    if pending:
+                        loop.run_until_complete(
+                            asyncio.gather(*pending, return_exceptions=True)
+                        )
+                except Exception:
+                    pass  # Ignore cleanup errors
+                finally:
+                    loop.close()
+                    # Clear the event loop reference to help with cleanup
+                    asyncio.set_event_loop(None)
+
+    # Run update check in background thread to avoid blocking startup
+    import threading
+
+    update_check_thread = threading.Thread(target=run_update_check, daemon=True)
+    update_check_thread.start()
+
+
 def _ensure_run_attributes(args):
     """
     Ensure run command attributes exist when defaulting to run.
@@ -657,6 +738,7 @@ def _execute_command(command: str, args) -> int:
         CLICommands.CLEANUP.value: cleanup_memory,
         CLICommands.MCP.value: manage_mcp,
         CLICommands.DOCTOR.value: run_doctor,
+        CLICommands.UPGRADE.value: upgrade,
         "debug": manage_debug,  # Add debug command
         "mpm-init": None,  # Will be handled separately with lazy import
     }

claude_mpm/cli/commands/upgrade.py

@@ -0,0 +1,152 @@
+"""
+Upgrade command implementation for claude-mpm.
+
+WHY: This module provides a manual upgrade command that allows users to check
+for and install the latest version of claude-mpm without waiting for the
+automatic startup check.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Leverage SelfUpgradeService for upgrade functionality
+- Support multiple installation methods (pip, pipx, npm)
+- Skip editable/development installations (must upgrade manually)
+- Provide clear feedback on available updates and upgrade progress
+"""
+
+import asyncio
+
+from ..shared import BaseCommand, CommandResult
+
+
+class UpgradeCommand(BaseCommand):
+    """Upgrade command using shared utilities."""
+
+    def __init__(self):
+        super().__init__("upgrade")
+
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        # Upgrade command doesn't require specific validation
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the upgrade command."""
+        try:
+            from ...services.self_upgrade_service import (
+                InstallationMethod,
+                SelfUpgradeService,
+            )
+
+            # Create upgrade service
+            upgrade_service = SelfUpgradeService()
+
+            # Check installation method
+            if upgrade_service.installation_method == InstallationMethod.EDITABLE:
+                self.logger.info(
+                    "Editable installation detected - upgrade must be done manually"
+                )
+                print("\n⚠️  Editable Installation Detected")
+                print(
+                    "\nYou are running claude-mpm from an editable installation (development mode)."
+                )
+                print("To upgrade, run:")
+                print("  cd /path/to/claude-mpm")
+                print("  git pull")
+                print("  pip install -e .")
+                return CommandResult.success_result(
+                    "Upgrade information provided for editable installation"
+                )
+
+            # Check for updates
+            print("\n🔍 Checking for updates...")
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                update_info = loop.run_until_complete(
+                    upgrade_service.check_for_update()
+                )
+            finally:
+                loop.close()
+
+            if not update_info or not update_info.get("update_available"):
+                print(
+                    f"\n✅ You are already on the latest version (v{upgrade_service.current_version})"
+                )
+                return CommandResult.success_result("Already on latest version")
+
+            # Display update information
+            current = update_info["current"]
+            latest = update_info["latest"]
+            method = update_info.get("installation_method", "unknown")
+
+            print("\n🎉 New version available!")
+            print(f"   Current: v{current}")
+            print(f"   Latest:  v{latest}")
+            print(f"   Installation method: {method}")
+
+            # Check if --yes flag is set for non-interactive upgrade
+            force_upgrade = getattr(args, "yes", False) or getattr(args, "force", False)
+
+            if not force_upgrade:
+                # Prompt user for confirmation
+                if not upgrade_service.prompt_for_upgrade(update_info):
+                    print("\n⏸️  Upgrade cancelled by user")
+                    return CommandResult.success_result("Upgrade cancelled by user")
+
+            # Perform upgrade
+            success, message = upgrade_service.perform_upgrade(update_info)
+            print(f"\n{message}")
+
+            if success:
+                # Restart after successful upgrade
+                upgrade_service.restart_after_upgrade()
+                # Note: This line won't be reached as restart replaces process
+                return CommandResult.success_result(f"Upgraded to v{latest}")
+            return CommandResult.error_result("Upgrade failed")
+
+        except Exception as e:
+            self.logger.error(f"Error during upgrade: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error during upgrade: {e}")
+
+
+def add_upgrade_parser(subparsers):
+    """
+    Add upgrade command parser.
+
+    WHY: This command helps users check for and install the latest version of
+    claude-mpm without waiting for the automatic startup check.
+
+    Args:
+        subparsers: The subparser action object to add the upgrade command to
+    """
+    parser = subparsers.add_parser(
+        "upgrade",
+        help="Check for and install latest claude-mpm version",
+        description="Check for updates and upgrade claude-mpm to the latest version from PyPI/npm",
+    )
+
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt and upgrade immediately if available",
+    )
+
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force upgrade even if already on latest version (alias for --yes)",
+    )
+
+    return parser
+
+
+def upgrade(args):
+    """
+    Main entry point for upgrade command.
+
+    This function maintains backward compatibility while using the new BaseCommand pattern.
+    """
+    command = UpgradeCommand()
+    result = command.execute(args)
+    return result.exit_code

claude_mpm/cli/parsers/base_parser.py

@@ -423,6 +423,11 @@ def create_parser(
 
         add_doctor_parser(subparsers)
 
+        # Add upgrade command
+        from ..commands.upgrade import add_upgrade_parser
+
+        add_upgrade_parser(subparsers)
+
         # Add verify command for MCP service verification
         from ..commands.verify import add_parser as add_verify_parser
 

claude_mpm/constants.py

@@ -44,6 +44,7 @@ class CLICommands(str, Enum):
     MCP = "mcp"
     DOCTOR = "doctor"
     DASHBOARD = "dashboard"
+    UPGRADE = "upgrade"
 
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""

claude_mpm/services/core/memory_manager.py

@@ -40,9 +40,11 @@ class MemoryManager(IMemoryManager):
     4. Legacy format migration (e.g., PM.md -> PM_memories.md)
     5. Memory caching for performance
 
-    Memory Loading Order:
-    - User-level memories: ~/.claude-mpm/memories/ (global defaults)
-    - Project-level memories: ./.claude-mpm/memories/ (overrides user)
+    Memory Scope:
+    - Project-level ONLY: ./.claude-mpm/memories/ (project-scoped isolation)
+    - User-level memories are NOT loaded to prevent cross-project contamination
+
+    Note: As of v4.7.10+, memories are strictly project-scoped for complete isolation.
     """
 
     def __init__(
@@ -279,7 +281,10 @@ class MemoryManager(IMemoryManager):
 
     def _load_actual_memories(self, deployed_agents: Set[str]) -> Dict[str, Any]:
         """
-        Load actual memories from both user and project directories.
+        Load actual memories from project directory only.
+
+        Memories are project-scoped to ensure complete isolation between projects.
+        User-level memories are no longer supported to prevent cross-project contamination.
 
         Args:
             deployed_agents: Set of deployed agent names
@@ -287,32 +292,14 @@ class MemoryManager(IMemoryManager):
         Returns:
             Dictionary with actual_memories and agent_memories
         """
-        # Define memory directories in priority order
-        user_memories_dir = Path.home() / ".claude-mpm" / "memories"
+        # Define project memory directory (project-scoped only)
         project_memories_dir = Path.cwd() / ".claude-mpm" / "memories"
 
         # Dictionary to store aggregated memories
         pm_memories = []
         agent_memories_dict = {}
 
-        # Load memories from user directory first
-        if user_memories_dir.exists():
-            self.logger.info(
-                f"Loading user-level memory files from: {user_memories_dir}"
-            )
-            self._load_memories_from_directory(
-                user_memories_dir,
-                deployed_agents,
-                pm_memories,
-                agent_memories_dict,
-                "user",
-            )
-        else:
-            self.logger.debug(
-                f"No user memories directory found at: {user_memories_dir}"
-            )
-
-        # Load memories from project directory (overrides user memories)
+        # Load memories from project directory only
         if project_memories_dir.exists():
             self.logger.info(
                 f"Loading project-level memory files from: {project_memories_dir}"

claude_mpm/services/self_upgrade_service.py

@@ -0,0 +1,342 @@
+"""
+Self-Upgrade Service
+====================
+
+Handles version checking and self-upgrade functionality for claude-mpm.
+Supports pip, pipx, and npm installations with automatic detection.
+
+WHY: Users should be notified of updates and have an easy way to upgrade
+without manually running installation commands.
+
+DESIGN DECISIONS:
+- Detects installation method (pip/pipx/npm/editable)
+- Non-blocking version checks with caching
+- Interactive upgrade prompts with confirmation
+- Automatic restart after upgrade
+- Graceful failure handling (never breaks existing installation)
+"""
+
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from packaging import version
+
+from ..core.logger import get_logger
+from ..core.unified_paths import PathContext
+from .mcp_gateway.utils.package_version_checker import PackageVersionChecker
+
+
+class InstallationMethod:
+    """Installation method enumeration."""
+
+    PIP = "pip"
+    PIPX = "pipx"
+    NPM = "npm"
+    EDITABLE = "editable"
+    UNKNOWN = "unknown"
+
+
+class SelfUpgradeService:
+    """
+    Service for checking and performing self-upgrades.
+
+    Capabilities:
+    - Detect current installation method
+    - Check PyPI/npm for latest version
+    - Prompt user for upgrade confirmation
+    - Execute upgrade command
+    - Restart after upgrade
+    """
+
+    def __init__(self):
+        """Initialize the self-upgrade service."""
+        self.logger = get_logger("SelfUpgradeService")
+        self.version_checker = PackageVersionChecker()
+        self.current_version = self._get_current_version()
+        self.installation_method = self._detect_installation_method()
+
+    def _get_current_version(self) -> str:
+        """
+        Get the current installed version.
+
+        Returns:
+            Version string (e.g., "4.7.10")
+        """
+        try:
+            from .. import __version__
+
+            return __version__
+        except ImportError:
+            # Fallback to VERSION file
+            try:
+                version_file = Path(__file__).parent.parent / "VERSION"
+                if version_file.exists():
+                    return version_file.read_text().strip()
+            except Exception:
+                pass
+
+        return "unknown"
+
+    def _detect_installation_method(self) -> str:
+        """
+        Detect how claude-mpm was installed.
+
+        Returns:
+            Installation method constant
+        """
+        # Check for editable install
+        if PathContext.detect_deployment_context().name in [
+            "DEVELOPMENT",
+            "EDITABLE_INSTALL",
+        ]:
+            return InstallationMethod.EDITABLE
+
+        # Check for pipx by looking at executable path
+        executable = sys.executable
+        if "pipx" in executable:
+            return InstallationMethod.PIPX
+
+        # Check if npm wrapper is present
+        try:
+            result = subprocess.run(
+                ["npm", "list", "-g", "claude-mpm"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and "claude-mpm" in result.stdout:
+                return InstallationMethod.NPM
+        except Exception:
+            pass
+
+        # Default to pip
+        return InstallationMethod.PIP
+
+    async def check_for_update(
+        self, cache_ttl: Optional[int] = None
+    ) -> Optional[Dict[str, any]]:
+        """
+        Check if an update is available.
+
+        Args:
+            cache_ttl: Cache time-to-live in seconds (default: 24 hours)
+
+        Returns:
+            Dict with update info or None:
+            {
+                "current": "4.7.10",
+                "latest": "4.7.11",
+                "update_available": True,
+                "installation_method": "pipx",
+                "upgrade_command": "pipx upgrade claude-mpm"
+            }
+        """
+        if self.current_version == "unknown":
+            self.logger.warning("Cannot check for updates: version unknown")
+            return None
+
+        # Check PyPI for Python installations
+        if self.installation_method in [
+            InstallationMethod.PIP,
+            InstallationMethod.PIPX,
+        ]:
+            result = await self.version_checker.check_for_update(
+                "claude-mpm", self.current_version, cache_ttl
+            )
+            if result and result.get("update_available"):
+                result["installation_method"] = self.installation_method
+                result["upgrade_command"] = self._get_upgrade_command()
+                return result
+
+        # Check npm for npm installations
+        elif self.installation_method == InstallationMethod.NPM:
+            npm_version = await self._check_npm_version()
+            if npm_version:
+                current_ver = version.parse(self.current_version)
+                latest_ver = version.parse(npm_version)
+                if latest_ver > current_ver:
+                    return {
+                        "current": self.current_version,
+                        "latest": npm_version,
+                        "update_available": True,
+                        "installation_method": InstallationMethod.NPM,
+                        "upgrade_command": self._get_upgrade_command(),
+                        "checked_at": datetime.now(timezone.utc).isoformat(),
+                    }
+
+        return None
+
+    async def _check_npm_version(self) -> Optional[str]:
+        """
+        Check npm registry for latest version.
+
+        Returns:
+            Latest version string or None
+        """
+        try:
+            result = subprocess.run(
+                ["npm", "view", "claude-mpm", "version"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except Exception as e:
+            self.logger.debug(f"npm version check failed: {e}")
+
+        return None
+
+    def _get_upgrade_command(self) -> str:
+        """
+        Get the appropriate upgrade command for current installation method.
+
+        Returns:
+            Shell command string to upgrade claude-mpm
+        """
+        if self.installation_method == InstallationMethod.PIPX:
+            return "pipx upgrade claude-mpm"
+        if self.installation_method == InstallationMethod.NPM:
+            return "npm update -g claude-mpm"
+        if self.installation_method == InstallationMethod.PIP:
+            return f"{sys.executable} -m pip install --upgrade claude-mpm"
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return "git pull && pip install -e ."
+        return "pip install --upgrade claude-mpm"
+
+    def prompt_for_upgrade(self, update_info: Dict[str, any]) -> bool:
+        """
+        Prompt user to upgrade.
+
+        Args:
+            update_info: Update information dict
+
+        Returns:
+            True if user confirms upgrade, False otherwise
+        """
+        current = update_info["current"]
+        latest = update_info["latest"]
+        method = update_info.get("installation_method", "unknown")
+
+        print("\n🎉 New version available!")
+        print(f"   Current: v{current}")
+        print(f"   Latest:  v{latest}")
+        print(f"   Installation method: {method}")
+        print(f"\nTo upgrade, run: {update_info['upgrade_command']}")
+
+        try:
+            response = input("\nWould you like to upgrade now? [y/N]: ").strip().lower()
+            return response in ["y", "yes"]
+        except (KeyboardInterrupt, EOFError):
+            print("\n")
+            return False
+
+    def perform_upgrade(self, update_info: Dict[str, any]) -> Tuple[bool, str]:
+        """
+        Perform the upgrade.
+
+        Args:
+            update_info: Update information dict
+
+        Returns:
+            Tuple of (success: bool, message: str)
+        """
+        command = update_info["upgrade_command"]
+
+        # Don't upgrade editable installs automatically
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return (
+                False,
+                "Editable installation detected. Please update manually with: git pull && pip install -e .",
+            )
+
+        print("\n⏳ Upgrading claude-mpm...")
+        print(f"   Running: {command}")
+
+        try:
+            # Execute upgrade command
+            result = subprocess.run(
+                command,
+                check=False,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minutes
+            )
+
+            if result.returncode == 0:
+                return (True, f"✅ Successfully upgraded to v{update_info['latest']}")
+            error_msg = result.stderr or result.stdout or "Unknown error"
+            return (False, f"❌ Upgrade failed: {error_msg}")
+
+        except subprocess.TimeoutExpired:
+            return (False, "❌ Upgrade timed out")
+        except Exception as e:
+            return (False, f"❌ Upgrade failed: {e!s}")
+
+    def restart_after_upgrade(self) -> None:
+        """
+        Restart claude-mpm after a successful upgrade.
+
+        Preserves original command line arguments.
+        """
+        print("\n🔄 Restarting claude-mpm...")
+
+        try:
+            # Get current command line arguments
+            args = sys.argv[:]
+
+            # Replace current process with new one
+            if self.installation_method == InstallationMethod.PIPX:
+                # Use pipx run
+                os.execvp("pipx", ["pipx", "run", "claude-mpm", *args[1:]])
+            elif self.installation_method == InstallationMethod.NPM:
+                # Use npm executable
+                os.execvp("claude-mpm", args)
+            else:
+                # Use Python executable
+                os.execvp(sys.executable, [sys.executable, *args])
+
+        except Exception as e:
+            self.logger.error(f"Failed to restart: {e}")
+            print(f"\n⚠️  Restart failed: {e}")
+            print("Please restart claude-mpm manually.")
+
+    async def check_and_prompt_on_startup(
+        self, auto_upgrade: bool = False
+    ) -> Optional[Dict[str, any]]:
+        """
+        Check for updates on startup and optionally prompt user.
+
+        Args:
+            auto_upgrade: If True, upgrade without prompting (use with caution)
+
+        Returns:
+            Update info if available, None otherwise
+        """
+        # Skip for editable installs
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return None
+
+        try:
+            update_info = await self.check_for_update()
+
+            if update_info and update_info.get("update_available"):
+                if auto_upgrade or self.prompt_for_upgrade(update_info):
+                    success, message = self.perform_upgrade(update_info)
+                    print(message)
+                    if success:
+                        self.restart_after_upgrade()
+
+                return update_info
+
+        except Exception as e:
+            self.logger.debug(f"Startup version check failed: {e}")
+
+        return None

{claude_mpm-4.7.9.dist-info → claude_mpm-4.7.11.dist-info}/METADATA

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

@@ -1,8 +1,8 @@
 claude_mpm/BUILD_NUMBER,sha256=9JfxhnDtr-8l3kCP2U5TVXSErptHoga8m7XA8zqgGOc,4
-claude_mpm/VERSION,sha256=7-IAGCtmvIwdixVQJDoq-zKnNOnvOHQb0ZEINbbBPJ4,6
+claude_mpm/VERSION,sha256=8NJI62Tp7GTnD5qeEDJUZAnPvuDLKbXAbLj5maMHLnM,7
 claude_mpm/__init__.py,sha256=UCw6j9e_tZQ3kJtTqmdfNv7MHyw9nD1jkj80WurwM2g,2064
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
-claude_mpm/constants.py,sha256=cChN3myrAcF3jC-6DvHnBFTEnwlDk-TAsIXPvUZr_yw,5953
+claude_mpm/constants.py,sha256=sLjJF6Kw7H4V9WWeaEYltM-77TgXqzEMX5vx4ukM5-0,5977
 claude_mpm/init.py,sha256=HFJR_JmTHa53FAhbGusm3P1iXT6VR6V7S-YJz4pOZ1Q,15967
 claude_mpm/ticket_wrapper.py,sha256=qe5xY579t7_7fK5nyeAfHN_fr7CXdeOD3jfXEc8-7yo,828
 claude_mpm/agents/BASE_AGENT_TEMPLATE.md,sha256=aK9qxS1FRpm_8VaB5GI2I6YA9Wr8dGHuea_txMFe44M,5524
@@ -64,7 +64,7 @@ claude_mpm/agents/templates/.claude-mpm/memories/README.md,sha256=vEiG7cPjHRZfwX
 claude_mpm/agents/templates/.claude-mpm/memories/engineer_memories.md,sha256=KMZSJrQi-wHOwfl2C0m3A4PpC4QuBtDolAtVybGahKc,77
 claude_mpm/agents/templates/logs/prompts/agent_engineer_20250826_014258_728.md,sha256=UBm4BycXtdaa-_l1VCh0alTGGOUSsnCbpKwbFuI-mUY,2219
 claude_mpm/agents/templates/logs/prompts/agent_engineer_20250901_010124_142.md,sha256=oPvFSYFnmJ4TkbTe4AZnNHWaJMJ-xqZP2WM6scUKQKo,13089
-claude_mpm/cli/__init__.py,sha256=0qyZe1R_9I_GJdyIfF6GatbZUVcaclxtvglPjN7dAIA,26270
+claude_mpm/cli/__init__.py,sha256=Ed8uPUqS5FmIAMxxIPxpo5JJX2ZWXIe5v-vx8K9jBEE,29373
 claude_mpm/cli/__main__.py,sha256=WnVGBwe10InxuZjJRFdwuMF6Gh16aXox6zFgxr0sRXk,847
 claude_mpm/cli/parser.py,sha256=Vqx9n-6Xo1uNhXR4rThmgWpZXTr0nOtkgDf3oMS9b0g,5855
 claude_mpm/cli/startup_logging.py,sha256=RTuyd6CbhiFQz7Z07LDDhK_ZAnZfuJ9B0NghVSntHFI,29390
@@ -102,6 +102,7 @@ claude_mpm/cli/commands/run.py,sha256=PB2H55piOPTy4yo4OBgbUCjMlcz9K79wbwpxQVc9m5
 claude_mpm/cli/commands/search.py,sha256=_0qbUnop8v758MHsB0fAop8FVxwygD59tec_-iN7pLE,9806
 claude_mpm/cli/commands/tickets.py,sha256=kl2dklTBnG3Y4jUUJ_PcEVsTx4CtVJfkGWboWBx_mQM,21234
 claude_mpm/cli/commands/uninstall.py,sha256=KGlVG6veEs1efLVjrZ3wSty7e1zVR9wpt-VXQA1RzWw,5945
+claude_mpm/cli/commands/upgrade.py,sha256=NYMVONNlj78WHoQ6eyVInroE95AeQxUY2_TpjYFTdYE,5409
 claude_mpm/cli/commands/verify.py,sha256=wmu2UYINK15q2e34TdlTyamvtLDE7r3Oj_XT9zpT5Kk,3687
 claude_mpm/cli/interactive/__init__.py,sha256=vQqUCgPFvLYA1Vkq-5pnY7Ow3A-IgdM0SByfNL1ZLTk,433
 claude_mpm/cli/interactive/agent_wizard.py,sha256=v3nKcLusU49ewjCqvgUWsG35UGc82pC7_Uv-ZzAHZ-c,36201
@@ -110,7 +111,7 @@ claude_mpm/cli/parsers/agent_manager_parser.py,sha256=TQEIm638ELM4X_AAGcn6WrJxlt
 claude_mpm/cli/parsers/agents_parser.py,sha256=R-9ESNXdjqr5iCEIcmbb2EPvcswW9UfJzMj5bAkgI4U,9042
 claude_mpm/cli/parsers/analyze_code_parser.py,sha256=cpJSMFbc3mqB4qrMBIEZiikzPekC2IQX-cjt9U2fHW4,5356
 claude_mpm/cli/parsers/analyze_parser.py,sha256=E00Ao0zwzbJPchs_AJt-aoQ7LQEtJPXRCNQ6Piivb4o,3908
-claude_mpm/cli/parsers/base_parser.py,sha256=Wejn4lAo-rMUQVP13PAehE6NoqmH2AD50HLKDf3QAKM,14169
+claude_mpm/cli/parsers/base_parser.py,sha256=iGYJ_-wIXkL4iVclJgrzQ2kz_of3CIqCwIM-FnFKEQI,14298
 claude_mpm/cli/parsers/config_parser.py,sha256=wp6NbV8_p9txP28MXFcQrri0JDIfGFM7u4aJbYJXcYQ,2699
 claude_mpm/cli/parsers/configure_parser.py,sha256=t3cwAQX3BfljDDRJH3i0LplpRprw5jdKcI9Uy3M8xtE,4382
 claude_mpm/cli/parsers/dashboard_parser.py,sha256=JBCM6v_iZhADr_Fwtk_d3up9AOod1avMab-vkNE61gE,3460
@@ -427,6 +428,7 @@ claude_mpm/services/project_port_allocator.py,sha256=L_EPuX_vGdv8vWWRVTpRk7F-v7u
 claude_mpm/services/recovery_manager.py,sha256=ptUYsguF6oKWnJnzPRSBuzUFVDXIcvsS3svT6MBTqCQ,25686
 claude_mpm/services/response_tracker.py,sha256=wBPgI5fH40xc7NHcCXQFOTPFTPSVbAZPqXIauXOJA5g,9575
 claude_mpm/services/runner_configuration_service.py,sha256=Qs84yrZfQv-DC0I2Xah1Qt9eunH4gS7LNMZ0mmymcqA,21311
+claude_mpm/services/self_upgrade_service.py,sha256=PuzHFQ3fQx7I9rmINLWs86o2KVyr-1StolLR-xnkOrQ,11246
 claude_mpm/services/session_management_service.py,sha256=axGZXpexWcYGnOMt5o8UQnFJUN3aVyjXRpFAcFrNKeg,10060
 claude_mpm/services/session_manager.py,sha256=ElguSoiy725VWS2iEqtcn0dUPIRrQrrON74aUzrWjRE,5147
 claude_mpm/services/socketio_client_manager.py,sha256=cZjIsnoi2VPXFA-5pNhoz5Vv3qv0iuSTy510TgAJU4U,18179
@@ -546,7 +548,7 @@ claude_mpm/services/core/__init__.py,sha256=evEayLlBqJvxMZhrhuK6aagXmNrKGSj8Jm9O
 claude_mpm/services/core/base.py,sha256=iA-F7DgGp-FJIMvQTiHQ68RkG_k-AtUWlArJPMw6ZPk,7297
 claude_mpm/services/core/cache_manager.py,sha256=dBHvvI6M67kaxFtAubi4IsWfbDZSct1siyKHTmCIrW8,11567
 claude_mpm/services/core/interfaces.py,sha256=FbLhWiOUMlvBfqjYBCeoWgsmRscQGBKteRMW-BGz4hQ,1261
-claude_mpm/services/core/memory_manager.py,sha256=2m-BYrNwh1yFjvz1VGB_Ndl_dtSp1xhpBcATaBiJQu0,26642
+claude_mpm/services/core/memory_manager.py,sha256=aajBuvBzTq0-EZrjnBjGRdUSaa6MpbfqHAtCePnn7aQ,26258
 claude_mpm/services/core/path_resolver.py,sha256=VtqiOEUlskAr9nRsaS9uXQSSjDD8dIrYfNML0zLY2zo,17764
 claude_mpm/services/core/service_container.py,sha256=3hDwFUahxFZnokPzwgXqBP9swvZhLztKQqwe9xEHgsw,18497
 claude_mpm/services/core/service_interfaces.py,sha256=dlNp0K4gaMcLiNSZxXjsL-kto6vipYw87pBuFK7oVNo,10770
@@ -786,9 +788,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=GprtAvu80VyMXcKGsK_VhYiXWA6BjKHv7O6HKx0AB9w,20917
 claude_mpm/validation/frontmatter_validator.py,sha256=YpJlYNNYcV8u6hIOi3_jaRsDnzhbcQpjCBE6eyBKaFY,7076
-claude_mpm-4.7.9.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.7.9.dist-info/METADATA,sha256=CKRPRgDYQjMEhisRDRh4swunx7DxHsVA022PufJ0t7Q,17517
-claude_mpm-4.7.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.7.9.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
-claude_mpm-4.7.9.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.7.9.dist-info/RECORD,,
+claude_mpm-4.7.11.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.7.11.dist-info/METADATA,sha256=xrQscwKCC7qPBxPTM3pLS0WWsrH6ale3r3620JQqids,17518
+claude_mpm-4.7.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.7.11.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
+claude_mpm-4.7.11.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.7.11.dist-info/RECORD,,