claude-mpm 4.2.39__py3-none-any.whl → 4.2.40__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.39
+4.2.40

claude_mpm/cli/__init__.py

@@ -106,11 +106,9 @@ def main(argv: Optional[list] = None):
         # Check for MCP auto-configuration (pipx installations)
         _check_mcp_auto_configuration()
 
-    # DISABLED: MCP pre-warming causes fork() issues with monitor daemon (v4.2.39)
-    # The pre-warming creates background threads that interfere with the monitor's
-    # daemonization process, causing race conditions and port binding errors.
-    # Accepting the 11.9s delay on first MCP use is better than a broken monitor.
-    # _verify_mcp_gateway_startup()
+    # Re-enabled: MCP pre-warming is safe with subprocess daemon (v4.2.40)
+    # The subprocess approach avoids fork() issues entirely
+    _verify_mcp_gateway_startup()
 
     # Set up logging
     # Special case: For MCP start command, we need minimal logging to avoid stdout interference

claude_mpm/services/cli/unified_dashboard_manager.py

@@ -133,7 +133,7 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
             if background:
                 # The daemon.start() method will handle cleanup when force_restart=True
                 # We don't need pre-emptive cleanup here as it causes race conditions
-                
+
                 # Try to start daemon with retry on port conflicts
                 max_retries = 3
                 retry_count = 0

claude_mpm/services/monitor/daemon.py

@@ -157,35 +157,67 @@ class UnifiedMonitorDaemon:
             )
             return False
 
-        # Wait for any pre-warming threads to complete before forking
-        self._wait_for_prewarm_completion()
-
-        # Use daemon manager's daemonize which includes cleanup
-        # DO NOT reset startup_status_file - it's needed for parent-child communication!
-        # self.daemon_manager.startup_status_file = None  # BUG: This breaks communication
-        success = self.daemon_manager.daemonize()
-        if not success:
-            return False
+        # Use subprocess approach for clean daemon startup (v4.2.40)
+        # This avoids all fork() + threading issues by starting in a fresh process
+        # The daemon_manager.use_subprocess_daemon() now checks for CLAUDE_MPM_SUBPROCESS_DAEMON
+        # environment variable to prevent infinite recursion
+        if self.daemon_manager.use_subprocess_daemon():
+            # Start using subprocess - this returns immediately in parent
+            success = self.daemon_manager.start_daemon_subprocess()
+            return success
+
+        # Check if we're in subprocess mode (environment variable set)
+        if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
+            # We're in a subprocess started by start_daemon_subprocess
+            # We need to write the PID file ourselves since parent didn't
+            self.logger.info("Running in subprocess daemon mode, writing PID file")
+            self.daemon_manager.write_pid_file()
+
+            # Setup signal handlers for graceful shutdown
+            self._setup_signal_handlers()
+
+            # Start the server (this will run until shutdown)
+            try:
+                result = self._run_server()
+                if not result:
+                    self.logger.error("Failed to start server in subprocess mode")
+                return result
+            except Exception as e:
+                self.logger.error(f"Server startup exception in subprocess: {e}")
+                raise
+        else:
+            # Legacy fork approach (kept for compatibility but not used by default)
+            # Wait for any pre-warming threads to complete before forking
+            self._wait_for_prewarm_completion()
+
+            # Use daemon manager's daemonize which includes cleanup
+            # DO NOT reset startup_status_file - it's needed for parent-child communication!
+            # self.daemon_manager.startup_status_file = None  # BUG: This breaks communication
+            success = self.daemon_manager.daemonize()
+            if not success:
+                return False
 
-        # We're now in the daemon process
-        # Update our PID references and status file
-        self.lifecycle.pid_file = self.daemon_manager.pid_file
-        self.lifecycle.startup_status_file = self.daemon_manager.startup_status_file
+            # We're now in the daemon process
+            # Update our PID references and status file
+            self.lifecycle.pid_file = self.daemon_manager.pid_file
+            self.lifecycle.startup_status_file = self.daemon_manager.startup_status_file
 
-        # Start the server in daemon mode
-        try:
-            result = self._run_server()
-            if not result:
-                # Report failure before exiting
-                self.daemon_manager._report_startup_error("Failed to start server")
-            else:
-                # Report success
-                self.daemon_manager._report_startup_success()
-            return result
-        except Exception as e:
-            # Report any exceptions during startup
-            self.daemon_manager._report_startup_error(f"Server startup exception: {e}")
-            raise
+            # Start the server in daemon mode
+            try:
+                result = self._run_server()
+                if not result:
+                    # Report failure before exiting
+                    self.daemon_manager._report_startup_error("Failed to start server")
+                else:
+                    # Report success
+                    self.daemon_manager._report_startup_success()
+                return result
+            except Exception as e:
+                # Report any exceptions during startup
+                self.daemon_manager._report_startup_error(
+                    f"Server startup exception: {e}"
+                )
+                raise
 
     def _start_foreground(self, force_restart: bool = False) -> bool:
         """Start in foreground mode.
@@ -602,29 +634,30 @@ class UnifiedMonitorDaemon:
                 self.logger.info(
                     f"Waiting for {len(active_threads)} background threads to complete before forking"
                 )
-                
+
                 # List thread names for debugging
                 thread_names = [t.name for t in active_threads]
                 self.logger.debug(f"Active threads: {thread_names}")
 
                 # Wait for threads to complete or timeout
                 while time.time() - start_time < timeout:
-                    remaining_threads = [
-                        t for t in active_threads if t.is_alive()
-                    ]
+                    remaining_threads = [t for t in active_threads if t.is_alive()]
                     if not remaining_threads:
                         self.logger.debug("All threads completed")
                         break
-                    
+
                     # Log remaining threads periodically
                     if int(time.time() - start_time) % 1 == 0:
-                        self.logger.debug(f"{len(remaining_threads)} threads still active")
-                    
+                        self.logger.debug(
+                            f"{len(remaining_threads)} threads still active"
+                        )
+
                     time.sleep(0.1)
-                
+
                 # Final check
                 final_threads = [
-                    t for t in threading.enumerate() 
+                    t
+                    for t in threading.enumerate()
                     if t.is_alive() and t != threading.current_thread()
                 ]
                 if final_threads:

claude_mpm/services/monitor/daemon_manager.py

@@ -149,7 +149,7 @@ class DaemonManager:
             # Try IPv4 first (most common)
             test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             test_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            
+
             # Use 127.0.0.1 for localhost to match what the server does
             bind_host = "127.0.0.1" if self.host == "localhost" else self.host
             test_sock.bind((bind_host, self.port))
@@ -201,7 +201,10 @@ class DaemonManager:
         try:
             # Find processes using the port
             result = subprocess.run(
-                ["lsof", "-ti", f":{self.port}"], capture_output=True, text=True, check=False
+                ["lsof", "-ti", f":{self.port}"],
+                capture_output=True,
+                text=True,
+                check=False,
             )
 
             if result.returncode != 0 or not result.stdout.strip():
@@ -220,35 +223,41 @@ class DaemonManager:
                     process_info = subprocess.run(
                         ["ps", "-p", str(pid), "-o", "comm="],
                         capture_output=True,
-                        text=True, check=False,
+                        text=True,
+                        check=False,
                     )
 
                     # Get full command to check if it's our monitor process
                     cmd_info = subprocess.run(
                         ["ps", "-p", str(pid), "-o", "command="],
                         capture_output=True,
-                        text=True, check=False,
+                        text=True,
+                        check=False,
                     )
-                    
+
                     if cmd_info.returncode != 0:
                         continue
-                        
+
                     full_command = cmd_info.stdout.strip().lower()
                     process_name = process_info.stdout.strip().lower()
-                    
+
                     # Check if this is our monitor/socketio process specifically
                     # Look for monitor, socketio, dashboard, or our specific port
-                    is_monitor = any([
-                        "monitor" in full_command,
-                        "socketio" in full_command,
-                        "dashboard" in full_command,
-                        f"port={self.port}" in full_command,
-                        f":{self.port}" in full_command,
-                        "unified_monitor" in full_command,
-                    ])
-                    
+                    is_monitor = any(
+                        [
+                            "monitor" in full_command,
+                            "socketio" in full_command,
+                            "dashboard" in full_command,
+                            f"port={self.port}" in full_command,
+                            f":{self.port}" in full_command,
+                            "unified_monitor" in full_command,
+                        ]
+                    )
+
                     if is_monitor and "python" in process_name:
-                        self.logger.info(f"Killing monitor process {pid}: {full_command[:100]}")
+                        self.logger.info(
+                            f"Killing monitor process {pid}: {full_command[:100]}"
+                        )
                         os.kill(pid, signal.SIGTERM)
 
                         # Wait briefly for graceful shutdown
@@ -329,7 +338,7 @@ class DaemonManager:
 
     def _kill_claude_mpm_processes(self) -> bool:
         """Kill any claude-mpm monitor processes specifically.
-        
+
         This targets monitor/dashboard/socketio processes only,
         NOT general Claude instances.
 
@@ -338,7 +347,9 @@ class DaemonManager:
         """
         try:
             # Look for monitor-specific processes
-            result = subprocess.run(["ps", "aux"], capture_output=True, text=True, check=False)
+            result = subprocess.run(
+                ["ps", "aux"], capture_output=True, text=True, check=False
+            )
 
             if result.returncode != 0:
                 return False
@@ -349,10 +360,14 @@ class DaemonManager:
             for line in lines:
                 line_lower = line.lower()
                 # Only target monitor/dashboard/socketio processes
-                if any(["monitor" in line_lower and "claude" in line_lower,
+                if any(
+                    [
+                        "monitor" in line_lower and "claude" in line_lower,
                         "dashboard" in line_lower and "claude" in line_lower,
                         "socketio" in line_lower,
-                        f":{self.port}" in line_lower and "python" in line_lower]):
+                        f":{self.port}" in line_lower and "python" in line_lower,
+                    ]
+                ):
                     parts = line.split()
                     if len(parts) > 1:
                         try:
@@ -395,7 +410,8 @@ class DaemonManager:
                     process_info = subprocess.run(
                         ["ps", "-p", str(pid), "-o", "comm="],
                         capture_output=True,
-                        text=True, check=False,
+                        text=True,
+                        check=False,
                     )
 
                     if "python" in process_info.stdout.lower():
@@ -441,7 +457,10 @@ class DaemonManager:
         """
         try:
             result = subprocess.run(
-                ["lsof", "-ti", f":{self.port}"], capture_output=True, text=True, check=False
+                ["lsof", "-ti", f":{self.port}"],
+                capture_output=True,
+                text=True,
+                check=False,
             )
 
             if result.returncode == 0 and result.stdout.strip():
@@ -485,9 +504,145 @@ class DaemonManager:
                 self.logger.error(f"Cannot start daemon - port {self.port} is in use")
                 return False
 
-            # Daemonize the process
+            # Use subprocess for clean daemon startup (v4.2.40)
+            # This avoids fork() issues with Python threading
+            if self.use_subprocess_daemon():
+                return self.start_daemon_subprocess()
+            # Fallback to traditional fork (kept for compatibility)
             return self.daemonize()
 
+    def use_subprocess_daemon(self) -> bool:
+        """Check if we should use subprocess instead of fork for daemonization.
+
+        Returns:
+            True to use subprocess (safer), False to use traditional fork
+        """
+        # Check if we're already in a subprocess to prevent infinite recursion
+        if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
+            # We're already in a subprocess, use traditional fork
+            return False
+
+        # Otherwise, use subprocess for monitor daemon to avoid threading issues
+        return True
+
+    def start_daemon_subprocess(self) -> bool:
+        """Start daemon using subprocess.Popen for clean process isolation.
+
+        This avoids all the fork() + threading issues by starting the monitor
+        in a completely fresh process with no inherited threads or locks.
+
+        Returns:
+            True if daemon started successfully
+        """
+        try:
+            # Build command to run monitor in foreground mode in subprocess
+            import sys
+
+            python_exe = sys.executable
+
+            # Run 'claude-mpm monitor start' in subprocess with environment variable
+            # to indicate we're already in a subprocess (prevents infinite recursion)
+            cmd = [
+                python_exe,
+                "-m",
+                "claude_mpm.cli",
+                "monitor",
+                "start",
+                "--background",  # Run as daemon
+                "--port",
+                str(self.port),
+                "--host",
+                self.host,
+            ]
+
+            # Set environment variable to prevent recursive subprocess creation
+            env = os.environ.copy()
+            env["CLAUDE_MPM_SUBPROCESS_DAEMON"] = "1"
+
+            self.logger.info(f"Starting monitor daemon via subprocess: {' '.join(cmd)}")
+
+            # Open log file for output redirection
+            log_file_handle = None
+            if self.log_file:
+                log_file_handle = open(self.log_file, "a")
+                log_file = log_file_handle
+            else:
+                log_file = subprocess.DEVNULL
+
+            try:
+                # Start the subprocess detached from parent
+                # Redirect stdout/stderr to log file to capture output
+                process = subprocess.Popen(
+                    cmd,
+                    stdin=subprocess.DEVNULL,
+                    stdout=log_file,
+                    stderr=subprocess.STDOUT if self.log_file else subprocess.DEVNULL,
+                    start_new_session=True,  # Create new process group
+                    close_fds=(
+                        False if self.log_file else True
+                    ),  # Keep log file open if redirecting
+                    env=env,  # Pass modified environment
+                )
+
+                # Close the log file handle now that subprocess has it
+                if log_file_handle:
+                    log_file_handle.close()
+
+                # Get the process PID
+                pid = process.pid
+                self.logger.info(f"Monitor subprocess started with PID {pid}")
+
+                # Wait for the subprocess to write its PID file
+                # The subprocess will write the PID file after it starts successfully
+                max_wait = 10  # seconds
+                start_time = time.time()
+
+                while time.time() - start_time < max_wait:
+                    # Check if process is still running
+                    if process.poll() is not None:
+                        # Process exited
+                        self.logger.error(
+                            f"Monitor daemon exited with code {process.returncode}"
+                        )
+                        return False
+
+                    # Check if PID file was written
+                    if self.pid_file.exists():
+                        try:
+                            with open(self.pid_file) as f:
+                                written_pid = int(f.read().strip())
+                            if written_pid == pid:
+                                # PID file written correctly, check port
+                                if (
+                                    not self._is_port_available()
+                                ):  # Port NOT available means it's in use (good!)
+                                    self.logger.info(
+                                        f"Monitor daemon successfully started on port {self.port}"
+                                    )
+                                    return True
+                        except:
+                            pass  # PID file not ready yet
+
+                    time.sleep(0.5)
+
+                # Timeout waiting for daemon to start
+                self.logger.error("Timeout waiting for monitor daemon to start")
+                # Try to kill the process if it's still running
+                if process.poll() is None:
+                    process.terminate()
+                    time.sleep(1)
+                    if process.poll() is None:
+                        process.kill()
+                return False
+            finally:
+                # Clean up log file handle if still open
+                if log_file_handle and not log_file_handle.closed:
+                    log_file_handle.close()
+
+        except Exception as e:
+            self.logger.error(f"Failed to start daemon via subprocess: {e}")
+            return False
+
     def daemonize(self) -> bool:
         """Daemonize the current process.
 
@@ -495,12 +650,14 @@ class DaemonManager:
             True if successful (in parent), doesn't return in child
         """
         # Guard against re-entrant execution after fork
-        if hasattr(self, '_forking_in_progress'):
-            self.logger.error("CRITICAL: Detected re-entrant daemonize call after fork!")
+        if hasattr(self, "_forking_in_progress"):
+            self.logger.error(
+                "CRITICAL: Detected re-entrant daemonize call after fork!"
+            )
             return False
-            
+
         self._forking_in_progress = True
-        
+
         try:
             # Clean up asyncio event loops before forking
             self._cleanup_event_loops()
@@ -787,7 +944,7 @@ class DaemonManager:
                     f.write("success")
                     f.flush()  # Ensure it's written immediately
                     os.fsync(f.fileno())  # Force write to disk
-            except Exception as e:
+            except Exception:
                 # Logging might not work in daemon process after fork
                 pass
 

claude_mpm/services/monitor/server.py

@@ -239,7 +239,11 @@ class UnifiedMonitorServer:
             except OSError as e:
                 # Port binding error - make sure it's reported clearly
                 # Check for common port binding errors
-                if "Address already in use" in str(e) or "[Errno 48]" in str(e) or "[Errno 98]" in str(e):
+                if (
+                    "Address already in use" in str(e)
+                    or "[Errno 48]" in str(e)
+                    or "[Errno 98]" in str(e)
+                ):
                     error_msg = f"Port {self.port} is already in use. Another process may be using this port."
                     self.logger.error(error_msg)
                     self.startup_error = error_msg

{claude_mpm-4.2.39.dist-info → claude_mpm-4.2.40.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=rPIlGse66RudpHHHZLBC5KxFCk-2bw29CGEogBG2IXc,7
+claude_mpm/VERSION,sha256=Ytc6ZB74poWqcejFEJHapI9Tv44jcmBlZEH-GuEoUwY,7
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=I946iCQzIIPRZVVJ8aO7lA4euiyDnNw2IX7EelAOkIE,5915
@@ -56,7 +56,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=5eW6ZPruxwWaHwIXyHByQkKUOhvMLwAax59iCU1MHVg,16863
+claude_mpm/cli/__init__.py,sha256=hbDc2PSEJHNRMhAYVAk1qPNCL5bTDOvU808VYBJEJgs,16670
 claude_mpm/cli/__main__.py,sha256=WnVGBwe10InxuZjJRFdwuMF6Gh16aXox6zFgxr0sRXk,847
 claude_mpm/cli/parser.py,sha256=Vqx9n-6Xo1uNhXR4rThmgWpZXTr0nOtkgDf3oMS9b0g,5855
 claude_mpm/cli/startup_logging.py,sha256=CWu43ecTJLLT-YHRL94c783XljpR8GKydycGJ1JFuXI,23462
@@ -436,7 +436,7 @@ claude_mpm/services/cli/memory_crud_service.py,sha256=ciN9Pl_12iDAqF9zPBWOzu-iXi
 claude_mpm/services/cli/memory_output_formatter.py,sha256=nbf7VsjGvH4e9fLv9c7PzjuO9COZhbK5P2fNZ79055w,24783
 claude_mpm/services/cli/session_manager.py,sha256=rla_Stbcvt93wa9G9MCMu9UqB3FLGqlPt_eN5lQb3Gg,16599
 claude_mpm/services/cli/startup_checker.py,sha256=efhuvu8ns5G16jcQ0nQZKVddmD2AktUEdlvjNcXjAuk,12232
-claude_mpm/services/cli/unified_dashboard_manager.py,sha256=YXb3hbyukTk-yycqLAIUTYe54lt0GFI5OyH6VrLL_RI,15449
+claude_mpm/services/cli/unified_dashboard_manager.py,sha256=XOXC7mlfmqwKrNDDbxu3q8qPn0oAUvPkQY7e_SwTTIA,15433
 claude_mpm/services/communication/__init__.py,sha256=b4qc7_Rqy4DE9q7BAUlfUZjoYG4uimAyUnE0irPcXyU,560
 claude_mpm/services/core/__init__.py,sha256=evEayLlBqJvxMZhrhuK6aagXmNrKGSj8Jm9OOxKzqvU,2195
 claude_mpm/services/core/base.py,sha256=iA-F7DgGp-FJIMvQTiHQ68RkG_k-AtUWlArJPMw6ZPk,7297
@@ -552,10 +552,10 @@ claude_mpm/services/memory/cache/__init__.py,sha256=6M6-P8ParyxX8vOgp_IxHgLMvacr
 claude_mpm/services/memory/cache/shared_prompt_cache.py,sha256=crnYPUT8zcS7TvoE1vW7pyaf4T77N5rJ1wUf_YQ2vvo,28704
 claude_mpm/services/memory/cache/simple_cache.py,sha256=qsTjbcsPxj-kNfaod9VN_uE5NioIwpfkUin_mMVUJCg,10218
 claude_mpm/services/monitor/__init__.py,sha256=X7gxSLUm9Fg_zEsX6LtCHP2ipF0qj6Emkun20h2So7g,745
-claude_mpm/services/monitor/daemon.py,sha256=YwwxMaqgcEzbP9eRUbmHodkhiNgn0oU2g7xpHDhd00w,24310
-claude_mpm/services/monitor/daemon_manager.py,sha256=0K0lhxNbPGIG6R_rS5B2r8OKJg2ZebVQuwSSDMN22bo,28237
+claude_mpm/services/monitor/daemon.py,sha256=ZeFZPoLKd8PGShNA-mRpFkQkQBbsP7iaDDlNJGCbFe0,25964
+claude_mpm/services/monitor/daemon_manager.py,sha256=fAcrRh-zBAHXP5_9s5WKCZ-V5EhTEijHPvrSJWwU7Yc,34238
 claude_mpm/services/monitor/event_emitter.py,sha256=JzRLNg8PUJ5s3ulNnq_D4yqCPItvidJzu8DmFxriieQ,12224
-claude_mpm/services/monitor/server.py,sha256=aKweXs3saNuPDaPwuoJT9g6kYYHefSiLcGmLdHD6FYM,28579
+claude_mpm/services/monitor/server.py,sha256=A8gBPqna_Yx5WT06_8OjHQuchgsWRXhfIOBYYtOTsI8,28659
 claude_mpm/services/monitor/handlers/__init__.py,sha256=jgPIf4IJVERm_tAeD9834tfx9IcxtlHj5r9rhEWpkfM,701
 claude_mpm/services/monitor/handlers/code_analysis.py,sha256=mHyI27Wp6WVmUBc0m0i991ogyFZBTvkrfR7Kf3EAk5U,11474
 claude_mpm/services/monitor/handlers/dashboard.py,sha256=uGBhb-6RG6u4WLipUXgdx7RCW-vb_qek5dIfHIwAC7o,9805
@@ -644,9 +644,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=zgiwLqh_17WxHpySvUPH65pb4bzIeUGOAYUJ
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=3Lo6LK-Mw9IdnL_bd3zl_R6FkgSVDYKUUM7EeVVD3jc,20865
 claude_mpm/validation/frontmatter_validator.py,sha256=u8g4Eyd_9O6ugj7Un47oSGh3kqv4wMkuks2i_CtWRvM,7028
-claude_mpm-4.2.39.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.2.39.dist-info/METADATA,sha256=mf2X8SRmS0EUaenCC01wANeEtZ-nZLLIFd-4m0c9v_4,14451
-claude_mpm-4.2.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.2.39.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.2.39.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.2.39.dist-info/RECORD,,
+claude_mpm-4.2.40.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.2.40.dist-info/METADATA,sha256=vAL5h1M9CdSo3Po_0evvbLYZixbc_un0p70-FZqLD4g,14451
+claude_mpm-4.2.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.2.40.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.2.40.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.2.40.dist-info/RECORD,,