claude-mpm 5.1.9__py3-none-any.whl → 5.4.3__py3-none-any.whl

claude_mpm/services/command_deployment_service.py

@@ -24,7 +24,6 @@ class CommandDeploymentService(BaseService):
         "mpm-agents.md",  # Replaced by mpm-agents-list.md
         "mpm-auto-configure.md",  # Replaced by mpm-agents-auto-configure.md
         "mpm-config.md",  # Replaced by mpm-config-view.md
-        "mpm-organize.md",  # Replaced by mpm-ticket-organize.md
         "mpm-resume.md",  # Replaced by mpm-session-resume.md
         "mpm-ticket.md",  # Replaced by mpm-ticket-view.md
     ]
@@ -316,7 +315,6 @@ class CommandDeploymentService(BaseService):
             "mpm-agents.md": "mpm-agents-list.md",
             "mpm-auto-configure.md": "mpm-agents-auto-configure.md",
             "mpm-config.md": "mpm-config-view.md",
-            "mpm-organize.md": "mpm-ticket-organize.md",
             "mpm-resume.md": "mpm-session-resume.md",
             "mpm-ticket.md": "mpm-ticket-view.md",
         }

claude_mpm/services/event_bus/config.py

@@ -52,9 +52,11 @@ class EventBusConfig:
     )
 
     # Relay configuration
+    # DirectSocketIORelay disabled by default - events already emit via direct sio.emit()
+    # Enable with CLAUDE_MPM_RELAY_ENABLED=true if needed for external consumers
     relay_enabled: bool = field(
         default_factory=lambda: os.environ.get(
-            "CLAUDE_MPM_RELAY_ENABLED", "true"
+            "CLAUDE_MPM_RELAY_ENABLED", "false"
         ).lower()
         == "true"
     )

claude_mpm/services/monitor/daemon.py

@@ -44,6 +44,7 @@ class UnifiedMonitorDaemon:
         daemon_mode: bool = False,
         pid_file: Optional[str] = None,
         log_file: Optional[str] = None,
+        enable_hot_reload: bool = False,
     ):
         """Initialize the unified monitor daemon.
 
@@ -53,10 +54,12 @@ class UnifiedMonitorDaemon:
             daemon_mode: Whether to run as background daemon
             pid_file: Path to PID file for daemon mode
             log_file: Path to log file for daemon mode
+            enable_hot_reload: Enable file watching and hot reload for development
         """
         self.host = host
         self.port = port
         self.daemon_mode = daemon_mode
+        self.enable_hot_reload = enable_hot_reload
         self.logger = get_logger(__name__)
 
         # Use new consolidated DaemonManager for all daemon operations
@@ -75,7 +78,9 @@ class UnifiedMonitorDaemon:
         )
 
         # Core server
-        self.server = UnifiedMonitorServer(host=host, port=port)
+        self.server = UnifiedMonitorServer(
+            host=host, port=port, enable_hot_reload=enable_hot_reload
+        )
 
         # Health monitoring
         self.health_monitor = HealthMonitor(port=port)
@@ -510,7 +515,9 @@ class UnifiedMonitorDaemon:
 
         # Recreate the server and health monitor after stop() sets them to None
         self.logger.info(f"Recreating server components for {self.host}:{self.port}")
-        self.server = UnifiedMonitorServer(host=self.host, port=self.port)
+        self.server = UnifiedMonitorServer(
+            host=self.host, port=self.port, enable_hot_reload=self.enable_hot_reload
+        )
         self.health_monitor = HealthMonitor(port=self.port)
 
         # Reset the shutdown event for the new run

claude_mpm/services/monitor/daemon_manager.py

@@ -34,6 +34,11 @@ from typing import Optional, Tuple
 from ...core.enums import OperationResult
 from ...core.logging_config import get_logger
 
+# Exit code constants for signal handling
+EXIT_NORMAL = 0
+EXIT_SIGKILL = 137  # 128 + SIGKILL(9) - forced termination
+EXIT_SIGTERM = 143  # 128 + SIGTERM(15) - graceful shutdown
+
 
 class DaemonManager:
     """Centralized manager for all daemon lifecycle operations.
@@ -556,7 +561,7 @@ class DaemonManager:
             # 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()
+                return self.start_daemon_subprocess(force_restart=force_restart)
             # Fallback to traditional fork (kept for compatibility)
             return self.daemonize()
 
@@ -574,12 +579,15 @@ class DaemonManager:
         # Otherwise, use subprocess for monitor daemon to avoid threading issues
         return True
 
-    def start_daemon_subprocess(self) -> bool:
+    def start_daemon_subprocess(self, force_restart: bool = False) -> 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.
 
+        Args:
+            force_restart: Whether this is a force restart (helps interpret exit codes)
+
         Returns:
             True if daemon started successfully
         """
@@ -652,7 +660,35 @@ class DaemonManager:
                     # Check if process is still running
                     returncode = process.poll()
                     if returncode is not None:
-                        # Process exited - this is the bug we're fixing!
+                        # Process exited - interpret exit code with context
+                        # Exit codes 137 (SIGKILL) and 143 (SIGTERM) are common during daemon replacement
+                        if returncode == EXIT_SIGKILL:
+                            # SIGKILL - process was forcefully terminated
+                            if force_restart:
+                                # This is expected during force restart - old daemon was killed
+                                self.logger.info(
+                                    f"Previous monitor instance replaced (exit {EXIT_SIGKILL}: SIGKILL during force restart)"
+                                )
+                            else:
+                                # Unexpected SIGKILL - something else killed our new daemon
+                                self.logger.warning(
+                                    f"Monitor subprocess terminated unexpectedly (exit {EXIT_SIGKILL}: SIGKILL). "
+                                    f"Check {self.log_file} for details."
+                                )
+                            return False
+                        if returncode == EXIT_SIGTERM:
+                            # SIGTERM - graceful shutdown requested
+                            self.logger.info(
+                                f"Monitor subprocess cleanly terminated (exit {EXIT_SIGTERM}: SIGTERM, graceful shutdown)"
+                            )
+                            return False
+                        if returncode == EXIT_NORMAL:
+                            # Normal exit
+                            self.logger.info(
+                                f"Monitor subprocess exited normally (exit code {EXIT_NORMAL})"
+                            )
+                            return False
+                        # Unexpected exit code - this IS an error
                         self.logger.error(
                             f"Monitor daemon subprocess exited prematurely with code {returncode}"
                         )

claude_mpm/services/monitor/server.py

@@ -15,7 +15,6 @@ DESIGN DECISIONS:
 """
 
 import asyncio
-import contextlib
 import os
 import threading
 import time
@@ -25,6 +24,8 @@ from typing import Dict, Optional
 
 import socketio
 from aiohttp import web
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
 
 from ...core.enums import ServiceState
 from ...core.logging_config import get_logger
@@ -45,6 +46,91 @@ except ImportError:
     EVENTBUS_AVAILABLE = False
 
 
+class SvelteBuildWatcher(FileSystemEventHandler):
+    """File watcher for Svelte build directory changes.
+
+    Watches for file changes in svelte-build directory and triggers
+    hot reload via Socket.IO event emission.
+
+    STABILITY FIX: Added thread lock and stop() method to prevent timer leaks.
+    """
+
+    def __init__(
+        self, sio: socketio.AsyncServer, loop: asyncio.AbstractEventLoop, logger
+    ):
+        """Initialize the file watcher.
+
+        Args:
+            sio: Socket.IO server instance for emitting events
+            loop: Event loop for async operations
+            logger: Logger instance
+        """
+        super().__init__()
+        self.sio = sio
+        self.loop = loop
+        self.logger = logger
+        self.debounce_timer = None
+        self.debounce_delay = 0.5  # Wait 500ms after last change
+        self._timer_lock = threading.Lock()  # STABILITY FIX: Prevent race condition
+
+    def stop(self):
+        """Stop the watcher and cancel any pending timers.
+
+        STABILITY FIX: Ensures timer is cancelled on shutdown.
+        """
+        with self._timer_lock:
+            if self.debounce_timer:
+                self.debounce_timer.cancel()
+                self.debounce_timer = None
+
+    def on_any_event(self, event):
+        """Handle any file system event.
+
+        Args:
+            event: File system event from watchdog
+        """
+        # Ignore directory events and temporary files
+        if event.is_directory or event.src_path.endswith((".tmp", ".swp", "~")):
+            return
+
+        self.logger.debug(
+            f"File change detected: {event.event_type} - {event.src_path}"
+        )
+
+        # STABILITY FIX: Use lock to prevent timer race condition
+        with self._timer_lock:
+            # Cancel existing timer
+            if self.debounce_timer:
+                self.debounce_timer.cancel()
+
+            # Schedule reload after debounce delay
+            self.debounce_timer = threading.Timer(
+                self.debounce_delay, self._trigger_reload
+            )
+            self.debounce_timer.start()
+
+    def _trigger_reload(self):
+        """Trigger hot reload by emitting Socket.IO event."""
+        try:
+            # Schedule the async emit in the event loop
+            asyncio.run_coroutine_threadsafe(self._emit_reload_event(), self.loop)
+            self.logger.info("Hot reload triggered - Svelte build changed")
+        except Exception as e:
+            self.logger.error(f"Error triggering reload: {e}")
+
+    async def _emit_reload_event(self):
+        """Emit the reload event to all connected clients."""
+        if self.sio:
+            await self.sio.emit(
+                "reload",
+                {
+                    "type": "reload",
+                    "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
+                    "reason": "svelte-build-updated",
+                },
+            )
+
+
 class UnifiedMonitorServer:
     """Unified server that combines HTTP dashboard and Socket.IO functionality.
 
@@ -52,15 +138,19 @@ class UnifiedMonitorServer:
     Replaces multiple competing server implementations with one stable solution.
     """
 
-    def __init__(self, host: str = "localhost", port: int = 8765):
+    def __init__(
+        self, host: str = "localhost", port: int = 8765, enable_hot_reload: bool = False
+    ):
         """Initialize the unified monitor server.
 
         Args:
             host: Host to bind to
             port: Port to bind to
+            enable_hot_reload: Enable file watching and hot reload for development
         """
         self.host = host
         self.port = port
+        self.enable_hot_reload = enable_hot_reload
         self.logger = get_logger(__name__)
 
         # Core components
@@ -78,6 +168,10 @@ class UnifiedMonitorServer:
         # High-performance event emitter
         self.event_emitter = None
 
+        # File watching (optional for dev mode)
+        self.file_observer: Optional[Observer] = None
+        self.file_watcher: Optional[SvelteBuildWatcher] = None
+
         # State
         self.running = False
         self.loop = None
@@ -184,6 +278,9 @@ class UnifiedMonitorServer:
 
                         time.sleep(0.1)
 
+                        # STABILITY FIX: Give tasks more time to clean up before closing
+                        time.sleep(0.5)
+
                         # Clear the event loop from the thread BEFORE closing
                         # This prevents other code from accidentally using it
                         asyncio.set_event_loop(None)
@@ -229,6 +326,10 @@ class UnifiedMonitorServer:
             self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
             self.logger.info("Heartbeat task started (3-minute interval)")
 
+            # Setup file watching for hot reload (if enabled)
+            if self.enable_hot_reload:
+                self._setup_file_watcher()
+
             # Setup HTTP routes
             self._setup_http_routes()
 
@@ -304,20 +405,64 @@ class UnifiedMonitorServer:
             self.logger.error(f"Error setting up event emitter: {e}")
             raise
 
+    def _setup_file_watcher(self):
+        """Setup file watcher for Svelte build directory.
+
+        Watches for changes in svelte-build and triggers hot reload.
+        Only enabled when enable_hot_reload is True.
+        """
+        try:
+            dashboard_dir = Path(__file__).resolve().parent.parent.parent / "dashboard"
+            svelte_build_dir = dashboard_dir / "static" / "svelte-build"
+
+            if not svelte_build_dir.exists():
+                self.logger.warning(
+                    f"Svelte build directory not found: {svelte_build_dir}. "
+                    "Hot reload disabled."
+                )
+                return
+
+            # Create file watcher with Socket.IO reference
+            self.file_watcher = SvelteBuildWatcher(
+                sio=self.sio, loop=self.loop, logger=self.logger
+            )
+
+            # Create observer and schedule watching
+            self.file_observer = Observer()
+            self.file_observer.schedule(
+                self.file_watcher, str(svelte_build_dir), recursive=True
+            )
+            self.file_observer.start()
+
+            self.logger.info(f"🔥 Hot reload enabled - watching {svelte_build_dir}")
+
+        except Exception as e:
+            self.logger.error(f"Error setting up file watcher: {e}")
+            # Don't raise - hot reload is optional
+
     def _setup_http_routes(self):
         """Setup HTTP routes for the dashboard."""
         try:
-            # Dashboard static files
-            dashboard_dir = Path(__file__).parent.parent.parent / "dashboard"
+            # Dashboard static files - use .resolve() for absolute path
+            dashboard_dir = Path(__file__).resolve().parent.parent.parent / "dashboard"
+            static_dir = dashboard_dir / "static"
 
-            # Main dashboard route
+            # Main dashboard route - serve Svelte dashboard
             async def dashboard_index(request):
-                template_path = dashboard_dir / "templates" / "index.html"
-                if template_path.exists():
-                    with template_path.open() as f:
+                svelte_index = static_dir / "svelte-build" / "index.html"
+                if svelte_index.exists():
+                    with svelte_index.open(encoding="utf-8") as f:
                         content = f.read()
                     return web.Response(text=content, content_type="text/html")
-                return web.Response(text="Dashboard not found", status=404)
+
+                # Log error with path details for debugging
+                self.logger.error(
+                    f"Dashboard index.html not found at: {svelte_index.resolve()}"
+                )
+                return web.Response(
+                    text=f"Dashboard not found. Expected location: {svelte_index.resolve()}",
+                    status=404,
+                )
 
             # Health check
             async def health_check(request):
@@ -325,7 +470,8 @@ class UnifiedMonitorServer:
                 version = "1.0.0"
                 try:
                     version_file = (
-                        Path(__file__).parent.parent.parent.parent.parent / "VERSION"
+                        Path(__file__).resolve().parent.parent.parent.parent.parent
+                        / "VERSION"
                     )
                     if version_file.exists():
                         version = version_file.read_text().strip()
@@ -546,12 +692,43 @@ class UnifiedMonitorServer:
                 "/monitor/events", lambda r: monitor_page_handler(r)
             )
 
-            # Static files with cache busting headers for development
-            static_dir = dashboard_dir / "static"
+            # Serve Svelte _app assets (compiled JS/CSS)
+            svelte_build_dir = static_dir / "svelte-build"
+            if svelte_build_dir.exists():
+                svelte_app_dir = svelte_build_dir / "_app"
+                if svelte_app_dir.exists():
+                    # Serve _app assets with proper caching
+                    async def app_assets_handler(request):
+                        """Serve Svelte _app assets."""
+                        from aiohttp.web_fileresponse import FileResponse
+
+                        rel_path = request.match_info["filepath"]
+                        file_path = svelte_app_dir / rel_path
+
+                        if not file_path.exists() or not file_path.is_file():
+                            raise web.HTTPNotFound()
+
+                        response = FileResponse(file_path)
+
+                        # Add cache headers for immutable assets
+                        if "/immutable/" in str(rel_path):
+                            response.headers["Cache-Control"] = (
+                                "public, max-age=31536000, immutable"
+                            )
+                        else:
+                            response.headers["Cache-Control"] = (
+                                "no-cache, no-store, must-revalidate"
+                            )
+
+                        return response
+
+                    self.app.router.add_get("/_app/{filepath:.*}", app_assets_handler)
+
+            # Legacy static files (for backward compatibility)
             if static_dir.exists():
 
                 async def static_handler(request):
-                    """Serve static files with cache-control headers for development."""
+                    """Serve legacy static files with cache-control headers for development."""
 
                     from aiohttp.web_fileresponse import FileResponse
 
@@ -576,10 +753,13 @@ class UnifiedMonitorServer:
 
                 self.app.router.add_get("/static/{filepath:.*}", static_handler)
 
-            # Templates
-            templates_dir = dashboard_dir / "templates"
-            if templates_dir.exists():
-                self.app.router.add_static("/templates/", templates_dir)
+            # Log dashboard availability
+            if svelte_build_dir.exists():
+                self.logger.info(
+                    f"✅ Svelte dashboard available at / (root) (build: {svelte_build_dir})"
+                )
+            else:
+                self.logger.warning(f"Svelte build not found at: {svelte_build_dir}")
 
             self.logger.info("HTTP routes registered successfully")
 
@@ -691,11 +871,37 @@ class UnifiedMonitorServer:
     async def _cleanup_async(self):
         """Cleanup async resources."""
         try:
+            # Stop file observer if running
+            # STABILITY FIX: Ensure watcher is stopped and verify observer termination
+            if self.file_observer:
+                try:
+                    # Stop the watcher first to cancel pending timers
+                    if self.file_watcher:
+                        self.file_watcher.stop()
+
+                    # Stop the observer
+                    self.file_observer.stop()
+                    self.file_observer.join(timeout=2)
+
+                    # Verify observer actually stopped
+                    if self.file_observer.is_alive():
+                        self.logger.warning("File observer did not stop cleanly")
+
+                    self.logger.debug("File observer stopped")
+                except Exception as e:
+                    self.logger.debug(f"Error stopping file observer: {e}")
+                finally:
+                    self.file_observer = None
+                    self.file_watcher = None
+
             # Cancel heartbeat task if running
+            # STABILITY FIX: Add timeout to prevent infinite wait on cancellation
             if self.heartbeat_task and not self.heartbeat_task.done():
                 self.heartbeat_task.cancel()
-                with contextlib.suppress(asyncio.CancelledError):
-                    await self.heartbeat_task
+                try:
+                    await asyncio.wait_for(self.heartbeat_task, timeout=2.0)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
                 self.logger.debug("Heartbeat task cancelled")
 
             # Close the Socket.IO server first to stop accepting new connections

claude_mpm/services/socketio/event_normalizer.py

@@ -78,10 +78,13 @@ class NormalizedEvent:
     subtype: str = ""  # Specific event type
     timestamp: str = ""  # ISO format timestamp
     data: Dict[str, Any] = field(default_factory=dict)  # Event payload
+    correlation_id: Optional[str] = (
+        None  # For correlating related events (e.g., pre_tool/post_tool)
+    )
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for emission."""
-        return {
+        result = {
             "event": self.event,
             "source": self.source,
             "type": self.type,
@@ -89,6 +92,10 @@ class NormalizedEvent:
             "timestamp": self.timestamp,
             "data": self.data,
         }
+        # Include correlation_id if present
+        if self.correlation_id:
+            result["correlation_id"] = self.correlation_id
+        return result
 
 
 class EventNormalizer:
@@ -218,6 +225,11 @@ class EventNormalizer:
             # Get or generate timestamp
             timestamp = self._extract_timestamp(event_data)
 
+            # Extract correlation_id if present
+            correlation_id = None
+            if isinstance(event_data, dict):
+                correlation_id = event_data.get("correlation_id")
+
             # Create normalized event
             normalized = NormalizedEvent(
                 event="claude_event",
@@ -226,6 +238,7 @@ class EventNormalizer:
                 subtype=subtype,
                 timestamp=timestamp,
                 data=data,
+                correlation_id=correlation_id,
             )
 
             self.stats["normalized"] += 1
@@ -281,6 +294,7 @@ class EventNormalizer:
                 "timestamp", datetime.now(timezone.utc).isoformat()
             ),
             data=event_data.get("data", {}),
+            correlation_id=event_data.get("correlation_id"),
         )
 
     def _extract_event_info(self, event_data: Any) -> Tuple[str, str, Dict[str, Any]]: