claude-mpm 4.2.9__tar.gz → 4.2.12__tar.gz

claude_mpm-4.2.12/BUILD_NUMBER

@@ -0,0 +1 @@
+341

{claude_mpm-4.2.9 → claude_mpm-4.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.9
+Version: 4.2.12
 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.12/VERSION

@@ -0,0 +1 @@
+4.2.12

{claude_mpm-4.2.9 → claude_mpm-4.2.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.2.9"
+version = "4.2.12"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -248,7 +248,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.2.9"
+version = "4.2.12"
 version_files = [
     "VERSION",
     "src/claude_mpm/VERSION",

claude_mpm-4.2.12/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.2.11

{claude_mpm-4.2.9 → claude_mpm-4.2.12}/src/claude_mpm/cli/commands/dashboard.py

@@ -5,21 +5,20 @@ WHY: This module provides CLI commands for managing the web dashboard interface,
 allowing users to start, stop, check status, and open the dashboard in a browser.
 
 DESIGN DECISIONS:
-- Use DashboardLauncher service for consistent dashboard management
+- Use UnifiedMonitorDaemon for integrated dashboard and monitoring
 - Support both foreground and background operation modes
-- Integrate with SocketIO server for real-time event streaming
+- Integrate with EventBus for real-time event streaming
 - Provide browser auto-opening functionality
 """
 
 import signal
 import sys
-import time
 from typing import Optional
 
 from ...constants import DashboardCommands
-from ...services.cli.dashboard_launcher import DashboardLauncher
+from ...services.cli.unified_dashboard_manager import UnifiedDashboardManager
+from ...services.monitor.daemon import UnifiedMonitorDaemon
 from ...services.port_manager import PortManager
-from ...services.socketio.dashboard_server import DashboardServer
 from ..shared import BaseCommand, CommandResult
 
 
@@ -28,7 +27,7 @@ class DashboardCommand(BaseCommand):
 
     def __init__(self):
         super().__init__("dashboard")
-        self.dashboard_launcher = DashboardLauncher(self.logger)
+        self.dashboard_manager = UnifiedDashboardManager(self.logger)
         self.port_manager = PortManager()
         self.server = None
 
@@ -79,20 +78,20 @@ class DashboardCommand(BaseCommand):
         )
 
         # Check if dashboard is already running
-        if self.dashboard_launcher.is_dashboard_running(port):
-            dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+        if self.dashboard_manager.is_dashboard_running(port):
+            dashboard_url = self.dashboard_manager.get_dashboard_url(port)
             return CommandResult.success_result(
                 f"Dashboard already running at {dashboard_url}",
                 data={"url": dashboard_url, "port": port},
             )
 
         if background:
-            # Use the dashboard launcher for background mode
-            success, browser_opened = self.dashboard_launcher.launch_dashboard(
-                port=port, monitor_mode=True
+            # Use the unified dashboard manager for background mode
+            success, browser_opened = self.dashboard_manager.start_dashboard(
+                port=port, background=True, open_browser=True
             )
             if success:
-                dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+                dashboard_url = self.dashboard_manager.get_dashboard_url(port)
                 return CommandResult.success_result(
                     f"Dashboard started at {dashboard_url}",
                     data={
@@ -103,110 +102,44 @@ class DashboardCommand(BaseCommand):
                 )
             return CommandResult.error_result("Failed to start dashboard in background")
 
-        # Run in foreground mode
-        server_started = False
+        # Run in foreground mode using unified monitor daemon
+        try:
+            self.logger.info("Starting unified monitor daemon with dashboard...")
+            print(f"Starting unified dashboard and monitor on {host}:{port}...")
+            print("Press Ctrl+C to stop the server")
+            print(
+                "\n✅ Using unified daemon - includes dashboard, monitoring, and EventBus integration\n"
+            )
 
-        # Try stable server first (or if explicitly requested)
-        if use_stable:
-            try:
-                self.logger.info(
-                    "Starting stable dashboard server (no monitor dependency)..."
-                )
-                print(f"Starting stable dashboard server on {host}:{port}...")
-                print("Press Ctrl+C to stop the server")
-                print("\n✅ Using stable server - works without monitor service\n")
-
-                # Create and run the stable server
-                from ...services.dashboard.stable_server import StableDashboardServer
-
-                stable_server = StableDashboardServer(host=host, port=port, debug=debug)
-
-                # Set up signal handlers for graceful shutdown
-                def signal_handler(signum, frame):
-                    print("\nShutting down dashboard server...")
-                    sys.exit(0)
-
-                signal.signal(signal.SIGINT, signal_handler)
-                signal.signal(signal.SIGTERM, signal_handler)
-
-                # Run the server (blocking)
-                result = stable_server.run()
-                if result:
-                    # Server ran successfully and stopped normally
-                    server_started = True
-                    return CommandResult.success_result("Dashboard server stopped")
-                # Server failed to start (e.g., couldn't find templates)
-                server_started = False
-                self.logger.warning(
-                    "Stable server failed to start, trying advanced server..."
-                )
+            # Create and start the unified monitor daemon
+            daemon = UnifiedMonitorDaemon(host=host, port=port, daemon_mode=False)
 
-            except KeyboardInterrupt:
-                print("\nDashboard server stopped by user")
-                return CommandResult.success_result("Dashboard server stopped")
-            except Exception as e:
-                self.logger.warning(f"Stable server failed: {e}")
-                if not getattr(args, "no_fallback", False):
-                    print(f"\n⚠️ Stable server failed: {e}")
-                    print("Attempting fallback to advanced server...")
-                else:
-                    return CommandResult.error_result(
-                        f"Failed to start stable dashboard: {e}"
-                    )
-
-        # Fallback to advanced DashboardServer if stable server failed or not requested
-        if not server_started and not getattr(args, "stable_only", False):
-            try:
-                self.logger.info(
-                    "Attempting to start advanced dashboard server with monitor..."
-                )
-                print(f"\nStarting advanced dashboard server on {host}:{port}...")
-                print("Note: This requires monitor service on port 8766")
-                print("Press Ctrl+C to stop the server")
-
-                # Create and start the Dashboard server (with monitor client)
-                self.server = DashboardServer(host=host, port=port)
-
-                # Set up signal handlers for graceful shutdown
-                def signal_handler(signum, frame):
-                    print("\nShutting down dashboard server...")
-                    if self.server:
-                        self.server.stop_sync()
-                    sys.exit(0)
-
-                signal.signal(signal.SIGINT, signal_handler)
-                signal.signal(signal.SIGTERM, signal_handler)
-
-                # Start the server (this starts in background thread)
-                self.server.start_sync()
-
-                # Keep the main thread alive while server is running
-                # The server runs in a background thread, so we need to block here
-                try:
-                    while self.server.is_running():
-                        time.sleep(1)
-                except KeyboardInterrupt:
-                    # Ctrl+C pressed, stop the server
-                    pass
-
-                # Server has stopped or user interrupted
-                if self.server:
-                    self.server.stop_sync()
-
-                return CommandResult.success_result("Dashboard server stopped")
-
-            except KeyboardInterrupt:
-                print("\nDashboard server stopped by user")
-                return CommandResult.success_result("Dashboard server stopped")
-            except Exception as e:
-                # If both servers fail, provide helpful error message
-                error_msg = f"Failed to start dashboard: {e}\n\n"
-                error_msg += "💡 Troubleshooting tips:\n"
-                error_msg += f"  - Check if port {port} is already in use\n"
-                error_msg += "  - Try running with --stable flag for standalone mode\n"
-                error_msg += "  - Use --debug flag for more details\n"
-                return CommandResult.error_result(error_msg)
-        return None
+            # Set up signal handlers for graceful shutdown
+            def signal_handler(signum, frame):
+                print("\nShutting down unified monitor daemon...")
+                daemon.stop()
+                sys.exit(0)
+
+            signal.signal(signal.SIGINT, signal_handler)
+            signal.signal(signal.SIGTERM, signal_handler)
+
+            # Start the daemon (blocking in foreground mode)
+            success = daemon.start()
+            if success:
+                return CommandResult.success_result("Unified monitor daemon stopped")
+            return CommandResult.error_result("Failed to start unified monitor daemon")
+
+        except KeyboardInterrupt:
+            print("\nUnified monitor daemon stopped by user")
+            return CommandResult.success_result("Unified monitor daemon stopped")
+        except Exception as e:
+            self.logger.error(f"Unified monitor daemon failed: {e}")
+            error_msg = f"Failed to start unified monitor daemon: {e}\n\n"
+            error_msg += "💡 Troubleshooting tips:\n"
+            error_msg += f"  - Check if port {port} is already in use\n"
+            error_msg += "  - Use --debug flag for more details\n"
+            error_msg += "  - Check that all dependencies are installed\n"
+            return CommandResult.error_result(error_msg)
 
     def _stop_dashboard(self, args) -> CommandResult:
         """Stop the dashboard server."""
@@ -214,10 +147,10 @@ class DashboardCommand(BaseCommand):
 
         self.logger.info(f"Stopping dashboard on port {port}")
 
-        if not self.dashboard_launcher.is_dashboard_running(port):
+        if not self.dashboard_manager.is_dashboard_running(port):
             return CommandResult.success_result(f"No dashboard running on port {port}")
 
-        if self.dashboard_launcher.stop_dashboard(port):
+        if self.dashboard_manager.stop_dashboard(port):
             return CommandResult.success_result(f"Dashboard stopped on port {port}")
 
         return CommandResult.error_result(f"Failed to stop dashboard on port {port}")
@@ -229,7 +162,7 @@ class DashboardCommand(BaseCommand):
 
         # Check default port first
         default_port = 8765
-        dashboard_running = self.dashboard_launcher.is_dashboard_running(default_port)
+        dashboard_running = self.dashboard_manager.is_dashboard_running(default_port)
 
         status_data = {
             "running": dashboard_running,
@@ -237,17 +170,17 @@ class DashboardCommand(BaseCommand):
         }
 
         if dashboard_running:
-            status_data["url"] = self.dashboard_launcher.get_dashboard_url(default_port)
+            status_data["url"] = self.dashboard_manager.get_dashboard_url(default_port)
 
         # Check all ports if requested
         if show_ports:
             port_status = {}
             for port in range(8765, 8786):
-                is_running = self.dashboard_launcher.is_dashboard_running(port)
+                is_running = self.dashboard_manager.is_dashboard_running(port)
                 port_status[port] = {
                     "running": is_running,
                     "url": (
-                        self.dashboard_launcher.get_dashboard_url(port)
+                        self.dashboard_manager.get_dashboard_url(port)
                         if is_running
                         else None
                     ),
@@ -280,14 +213,14 @@ class DashboardCommand(BaseCommand):
         port = getattr(args, "port", 8765)
 
         # Check if dashboard is running
-        if not self.dashboard_launcher.is_dashboard_running(port):
+        if not self.dashboard_manager.is_dashboard_running(port):
             self.logger.info("Dashboard not running, starting it first...")
             # Start dashboard in background
-            success, browser_opened = self.dashboard_launcher.launch_dashboard(
-                port=port, monitor_mode=True
+            success, browser_opened = self.dashboard_manager.start_dashboard(
+                port=port, background=True, open_browser=True
             )
             if success:
-                dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+                dashboard_url = self.dashboard_manager.get_dashboard_url(port)
                 return CommandResult.success_result(
                     f"Dashboard started and opened at {dashboard_url}",
                     data={
@@ -298,8 +231,8 @@ class DashboardCommand(BaseCommand):
                 )
             return CommandResult.error_result("Failed to start and open dashboard")
         # Dashboard already running, just open browser
-        dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
-        if self.dashboard_launcher._open_browser(dashboard_url):
+        dashboard_url = self.dashboard_manager.get_dashboard_url(port)
+        if self.dashboard_manager.open_browser(dashboard_url):
             return CommandResult.success_result(
                 f"Opened dashboard at {dashboard_url}",
                 data={"url": dashboard_url, "port": port},

claude_mpm-4.2.12/src/claude_mpm/cli/commands/monitor.py

@@ -0,0 +1,189 @@
+"""
+Monitor command implementation for claude-mpm.
+
+WHY: This module provides CLI commands for managing the unified monitoring daemon,
+providing a single stable way to launch all monitoring functionality including
+HTTP dashboard, Socket.IO events, real AST analysis, and Claude Code hook ingestion.
+
+DESIGN DECISIONS:
+- Use UnifiedMonitorDaemon for single stable monitoring service
+- Single port (8765) for all functionality
+- Support both foreground and daemon modes
+- Real AST analysis using CodeTreeAnalyzer
+- Integrated dashboard and Socket.IO server
+"""
+
+from typing import Optional
+
+from ...constants import MonitorCommands
+from ...services.monitor.daemon import UnifiedMonitorDaemon
+from ..shared import BaseCommand, CommandResult
+
+
+class MonitorCommand(BaseCommand):
+    """Monitor command for managing the unified monitoring daemon."""
+
+    def __init__(self):
+        super().__init__("monitor")
+        self.daemon = None
+
+    def validate_args(self, args) -> Optional[str]:
+        """Validate command arguments."""
+        # Monitor command allows no subcommand (defaults to status)
+        if hasattr(args, "monitor_command") and args.monitor_command:
+            valid_commands = [cmd.value for cmd in MonitorCommands]
+            if args.monitor_command not in valid_commands:
+                return f"Unknown monitor command: {args.monitor_command}. Valid commands: {', '.join(valid_commands)}"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the monitor command using unified monitoring daemon."""
+        try:
+            self.logger.info("Monitor command using unified monitoring daemon")
+
+            # Handle default case (no subcommand) - default to status
+            if not hasattr(args, "monitor_command") or not args.monitor_command:
+                return self._status_monitor(args)
+
+            # Route to specific monitor commands
+            if args.monitor_command == MonitorCommands.START.value:
+                return self._start_monitor(args)
+            if args.monitor_command == MonitorCommands.STOP.value:
+                return self._stop_monitor(args)
+            if args.monitor_command == MonitorCommands.RESTART.value:
+                return self._restart_monitor(args)
+            if args.monitor_command == MonitorCommands.STATUS.value:
+                return self._status_monitor(args)
+
+            return CommandResult.error_result(
+                f"Unknown monitor command: {args.monitor_command}"
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error executing monitor command: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error executing monitor command: {e}")
+
+    def _start_monitor(self, args) -> CommandResult:
+        """Start the unified monitor daemon."""
+        port = getattr(args, "port", None)
+        if port is None:
+            port = 8765  # Default to 8765 for unified monitor
+        host = getattr(args, "host", "localhost")
+
+        # Check for explicit foreground flag first, then background flag
+        # Default to daemon/background mode if neither specified
+        if getattr(args, "foreground", False):
+            daemon_mode = False
+        elif getattr(args, "background", None) is not None:
+            daemon_mode = getattr(args, "background", False)
+        else:
+            # Default to daemon/background mode
+            daemon_mode = True
+
+        mode_str = "background/daemon" if daemon_mode else "foreground"
+        self.logger.info(
+            f"Starting unified monitor daemon on {host}:{port} (mode: {mode_str})"
+        )
+
+        # Create unified monitor daemon
+        self.daemon = UnifiedMonitorDaemon(
+            host=host, port=port, daemon_mode=daemon_mode
+        )
+
+        # Check if already running
+        if self.daemon.lifecycle.is_running():
+            existing_pid = self.daemon.lifecycle.get_pid()
+            return CommandResult.success_result(
+                f"Unified monitor daemon already running with PID {existing_pid}",
+                data={
+                    "url": f"http://{host}:{port}",
+                    "port": port,
+                    "pid": existing_pid,
+                },
+            )
+
+        # Start the daemon
+        if self.daemon.start():
+            mode_info = " in background" if daemon_mode else " in foreground"
+            return CommandResult.success_result(
+                f"Unified monitor daemon started on {host}:{port}{mode_info}",
+                data={"url": f"http://{host}:{port}", "port": port, "mode": mode_str},
+            )
+        return CommandResult.error_result("Failed to start unified monitor daemon")
+
+    def _stop_monitor(self, args) -> CommandResult:
+        """Stop the unified monitor daemon."""
+        self.logger.info("Stopping unified monitor daemon")
+
+        # Create daemon instance to check status and stop
+        daemon = UnifiedMonitorDaemon()
+
+        if not daemon.lifecycle.is_running():
+            return CommandResult.success_result("No unified monitor daemon running")
+
+        # Stop the daemon by PID (works for both daemon and foreground mode)
+        if daemon.lifecycle.stop_daemon():
+            return CommandResult.success_result("Unified monitor daemon stopped")
+        return CommandResult.error_result("Failed to stop unified monitor daemon")
+
+    def _restart_monitor(self, args) -> CommandResult:
+        """Restart the unified monitor daemon."""
+        self.logger.info("Restarting unified monitor daemon")
+
+        # Create daemon instance
+        daemon = UnifiedMonitorDaemon()
+
+        # Restart the daemon
+        if daemon.restart():
+            return CommandResult.success_result("Unified monitor daemon restarted")
+        return CommandResult.error_result("Failed to restart unified monitor daemon")
+
+    def _status_monitor(self, args) -> CommandResult:
+        """Get unified monitor daemon status."""
+        verbose = getattr(args, "verbose", False)
+
+        # Create daemon instance to check status
+        daemon = UnifiedMonitorDaemon()
+        status_data = daemon.status()
+
+        # Format output message
+        if status_data["running"]:
+            message = f"Unified monitor daemon is running at http://{status_data['host']}:{status_data['port']}"
+            if status_data.get("pid"):
+                message += f" (PID: {status_data['pid']})"
+        else:
+            message = "Unified monitor daemon is not running"
+
+        return CommandResult.success_result(message, data=status_data)
+
+
+def manage_monitor(args):
+    """
+    Main entry point for monitor command.
+
+    The monitor command manages the unified monitoring daemon that provides
+    a single stable way to launch all monitoring functionality including
+    HTTP dashboard, Socket.IO events, real AST analysis, and Claude Code hooks.
+    """
+    command = MonitorCommand()
+    error = command.validate_args(args)
+
+    if error:
+        command.logger.error(error)
+        print(f"Error: {error}")
+        return 1
+
+    result = command.run(args)
+
+    if result.success:
+        if result.message:
+            print(result.message)
+        if result.data and getattr(args, "verbose", False):
+            import json
+
+            print(json.dumps(result.data, indent=2))
+        return 0
+    if result.message:
+        print(f"Error: {result.message}")
+    return 1

{claude_mpm-4.2.9 → claude_mpm-4.2.12}/src/claude_mpm/cli/commands/run.py

@@ -21,10 +21,11 @@ from typing import Optional
 from ...constants import LogLevel
 from ...core.logger import get_logger
 from ...core.unified_paths import get_scripts_dir
-from ...services.cli.dashboard_launcher import DashboardLauncher
 from ...services.cli.session_manager import SessionManager
-from ...services.cli.socketio_manager import SocketIOManager
+
+# SocketIOManager functionality now provided by UnifiedDashboardManager
 from ...services.cli.startup_checker import StartupCheckerService
+from ...services.cli.unified_dashboard_manager import UnifiedDashboardManager
 from ..shared import BaseCommand, CommandResult
 from ..startup_logging import (
     cleanup_old_startup_logs,
@@ -423,16 +424,16 @@ class RunCommand(BaseCommand):
                 self.logger.warning(f"Dependency check failed: {e}")
 
     def _setup_monitoring(self, args):
-        """Setup monitoring configuration using SocketIOManager."""
+        """Setup monitoring configuration using UnifiedDashboardManager."""
         monitor_mode = getattr(args, "monitor", False)
         websocket_port = 8765  # Default port
 
         if monitor_mode:
-            # Use SocketIOManager for server management
-            socketio_manager = SocketIOManager(self.logger)
+            # Use UnifiedDashboardManager for server management
+            dashboard_manager = UnifiedDashboardManager(self.logger)
 
             # Check dependencies
-            deps_ok, error_msg = socketio_manager.ensure_dependencies()
+            deps_ok, error_msg = dashboard_manager.ensure_dependencies()
             if not deps_ok:
                 self.logger.warning(
                     f"Socket.IO dependencies not available: {error_msg}, disabling monitor mode"
@@ -440,8 +441,8 @@ class RunCommand(BaseCommand):
                 monitor_mode = False
             else:
                 # Find available port and start server
-                websocket_port = socketio_manager.find_available_port(8765)
-                success, server_info = socketio_manager.start_server(
+                websocket_port = dashboard_manager.find_available_port(8765)
+                success, server_info = dashboard_manager.start_server(
                     port=websocket_port
                 )
 
@@ -451,12 +452,12 @@ class RunCommand(BaseCommand):
                     )
                     monitor_mode = False
                 else:
-                    # Use DashboardLauncher for browser opening only
-                    dashboard_launcher = DashboardLauncher(self.logger)
-                    monitor_url = dashboard_launcher.get_dashboard_url(websocket_port)
+                    # Use UnifiedDashboardManager for browser opening only
+                    dashboard_manager = UnifiedDashboardManager(self.logger)
+                    monitor_url = dashboard_manager.get_dashboard_url(websocket_port)
 
                     # Try to open browser
-                    browser_opened = dashboard_launcher._open_browser(monitor_url)
+                    browser_opened = dashboard_manager.open_browser(monitor_url)
                     args._browser_opened_by_cli = browser_opened
 
                     if not browser_opened:
@@ -855,12 +856,12 @@ def run_session_legacy(args):
 
     # Display Socket.IO server info if enabled
     if enable_websocket:
-        # Use SocketIOManager for server management
-        socketio_manager = SocketIOManager(logger)
+        # Use UnifiedDashboardManager for server management
+        dashboard_manager = UnifiedDashboardManager(logger)
 
         # Check dependencies
         print("🔧 Checking Socket.IO dependencies...")
-        deps_ok, error_msg = socketio_manager.ensure_dependencies()
+        deps_ok, error_msg = dashboard_manager.ensure_dependencies()
 
         if not deps_ok:
             print(f"❌ Failed to install Socket.IO dependencies: {error_msg}")
@@ -874,8 +875,8 @@ def run_session_legacy(args):
 
             # Find available port and start server if in monitor mode
             if monitor_mode:
-                websocket_port = socketio_manager.find_available_port(websocket_port)
-                success, server_info = socketio_manager.start_server(
+                websocket_port = dashboard_manager.find_available_port(websocket_port)
+                success, server_info = dashboard_manager.start_server(
                     port=websocket_port
                 )
 
@@ -886,10 +887,10 @@ def run_session_legacy(args):
                             "  Note: Socket.IO monitoring using exec mode with Claude Code hooks"
                         )
 
-                    # Use DashboardLauncher for browser opening
-                    dashboard_launcher = DashboardLauncher(logger)
-                    monitor_url = dashboard_launcher.get_dashboard_url(websocket_port)
-                    browser_opened = dashboard_launcher._open_browser(monitor_url)
+                    # Use UnifiedDashboardManager for browser opening
+                    dashboard_manager = UnifiedDashboardManager(logger)
+                    monitor_url = dashboard_manager.get_dashboard_url(websocket_port)
+                    browser_opened = dashboard_manager.open_browser(monitor_url)
                     args._browser_opened_by_cli = browser_opened
 
                     if not browser_opened:
@@ -971,16 +972,15 @@ def run_session_legacy(args):
         runner.run_interactive(context)
 
 
-# Legacy helper functions - now delegating to SocketIOManager
+# Legacy helper functions - now delegating to UnifiedDashboardManager
 def launch_socketio_monitor(port, logger):
     """Launch the Socket.IO monitoring dashboard (legacy compatibility)."""
-    socketio_manager = SocketIOManager(logger)
-    success, server_info = socketio_manager.start_server(port=port)
+    dashboard_manager = UnifiedDashboardManager(logger)
+    success, server_info = dashboard_manager.start_server(port=port)
 
     if success:
-        # Open browser using DashboardLauncher
-        launcher = DashboardLauncher(logger)
-        browser_opened = launcher._open_browser(server_info.url)
+        # Open browser using UnifiedDashboardManager
+        browser_opened = dashboard_manager.open_browser(server_info.url)
         return success, browser_opened
 
     return False, False
@@ -988,21 +988,21 @@ def launch_socketio_monitor(port, logger):
 
 def _check_socketio_server_running(port, logger):
     """Check if a Socket.IO server is running on the specified port (legacy compatibility)."""
-    socketio_manager = SocketIOManager(logger)
-    return socketio_manager.is_server_running(port)
+    dashboard_manager = UnifiedDashboardManager(logger)
+    return dashboard_manager.is_server_running(port)
 
 
 def _start_standalone_socketio_server(port, logger):
     """Start a standalone Socket.IO server (legacy compatibility)."""
-    socketio_manager = SocketIOManager(logger)
-    success, _ = socketio_manager.start_server(port=port)
+    dashboard_manager = UnifiedDashboardManager(logger)
+    success, _ = dashboard_manager.start_server(port=port)
     return success
 
 
 def open_in_browser_tab(url, logger):
     """Open URL in browser, attempting to reuse existing tabs when possible."""
-    launcher = DashboardLauncher(logger)
-    return launcher._open_browser(url)
+    manager = UnifiedDashboardManager(logger)
+    return manager.open_browser(url)
 
 
 def _check_claude_json_memory(args, logger):