claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

claude_mpm/core/claude_runner.py

@@ -1,44 +1,33 @@
 """Claude runner with both exec and subprocess launch methods."""
 
-import json
 import os
-import subprocess
-import sys
-import time
-from datetime import datetime
 from pathlib import Path
 from typing import Optional
-import uuid
-
-try:
-    from claude_mpm.services.agent_deployment import AgentDeploymentService
-    from claude_mpm.services.ticket_manager import TicketManager
-    from claude_mpm.services.hook_service import HookService
-    from claude_mpm.core.config import Config
-    from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
-except ImportError:
-    from claude_mpm.services.agent_deployment import AgentDeploymentService
-    from claude_mpm.services.ticket_manager import TicketManager
-    from claude_mpm.services.hook_service import HookService
-    from claude_mpm.core.config import Config
-    from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
+
+# Core imports that don't cause circular dependencies
+from claude_mpm.core.container import get_container
+from claude_mpm.core.interfaces import AgentDeploymentInterface
+from claude_mpm.core.logging_config import get_logger
+from claude_mpm.services.core.interfaces import RunnerConfigurationInterface
+
+# Type checking imports to avoid circular dependencies
 
 
 class ClaudeRunner:
     """
     Claude runner that replaces the entire orchestrator system.
-    
+
     This does exactly what we need:
     1. Deploy native agents to .claude/agents/
     2. Run Claude CLI with either exec or subprocess
     3. Extract tickets if needed
     4. Handle both interactive and non-interactive modes
-    
+
     Supports two launch methods:
     - exec: Replace current process (default for backward compatibility)
     - subprocess: Launch as child process for more control
     """
-    
+
     def __init__(
         self,
         enable_tickets: bool = True,
@@ -46,984 +35,775 @@ class ClaudeRunner:
         claude_args: Optional[list] = None,
         launch_method: str = "exec",  # "exec" or "subprocess"
         enable_websocket: bool = False,
-        websocket_port: int = 8765
+        websocket_port: int = 8765,
+        use_native_agents: bool = False,  # Use --agents flag instead of file deployment
     ):
-        """Initialize the Claude runner."""
-        self.enable_tickets = enable_tickets
-        self.log_level = log_level
-        self.logger = get_logger("claude_runner")
-        self.claude_args = claude_args or []
-        self.launch_method = launch_method
-        self.enable_websocket = enable_websocket
-        self.websocket_port = websocket_port
-        
-        # Initialize project logger for session logging
-        self.project_logger = None
-        if log_level != "OFF":
-            try:
-                self.project_logger = get_project_logger(log_level)
-                self.project_logger.log_system(
-                    f"Initializing ClaudeRunner with {launch_method} launcher",
-                    level="INFO",
-                    component="runner"
-                )
-            except Exception as e:
-                self.logger.warning(f"Failed to initialize project logger: {e}")
-        
-        # Initialize services
-        self.deployment_service = AgentDeploymentService()
-        if enable_tickets:
-            try:
-                self.ticket_manager = TicketManager()
-            except (ImportError, TypeError, Exception) as e:
-                self.logger.warning(f"Ticket manager not available: {e}")
-                self.ticket_manager = None
-                self.enable_tickets = False
-        
-        # Initialize hook service and register memory hooks
-        self.config = Config()
-        self.hook_service = HookService(self.config)
-        self._register_memory_hooks()
-        
-        # Load system instructions
-        self.system_instructions = self._load_system_instructions()
-        
-        # Track if we need to create session logs
-        self.session_log_file = None
-        if self.project_logger and log_level != "OFF":
-            try:
-                # Create a system.jsonl file in the session directory
-                self.session_log_file = self.project_logger.session_dir / "system.jsonl"
-                self._log_session_event({
+        """Initialize the Claude runner.
+
+        Args:
+            enable_tickets: Enable ticket extraction (deprecated)
+            log_level: Logging level
+            claude_args: Additional arguments for Claude CLI
+            launch_method: "exec" or "subprocess" launch mode
+            enable_websocket: Enable WebSocket server
+            websocket_port: WebSocket server port
+            use_native_agents: Use --agents CLI flag instead of .claude/agents/ deployment
+        """
+        self.logger = get_logger(__name__)
+
+        # Initialize configuration service
+        container = get_container()
+        if not container.is_registered(RunnerConfigurationInterface):
+            from claude_mpm.services.runner_configuration_service import (
+                RunnerConfigurationService,
+            )
+
+            container.register_singleton(
+                RunnerConfigurationInterface, RunnerConfigurationService
+            )
+
+        try:
+            self.configuration_service = container.get(RunnerConfigurationInterface)
+        except Exception as e:
+            self.logger.error(
+                "Failed to initialize configuration service", exc_info=True
+            )
+            raise RuntimeError(
+                f"Configuration service initialization failed: {e}"
+            ) from e
+
+        # Initialize configuration using the service
+        config_data = self.configuration_service.initialize_configuration(
+            enable_tickets=enable_tickets,
+            log_level=log_level,
+            claude_args=claude_args,
+            launch_method=launch_method,
+            enable_websocket=enable_websocket,
+            websocket_port=websocket_port,
+            use_native_agents=use_native_agents,
+        )
+
+        # Set configuration attributes
+        self.enable_tickets = config_data["enable_tickets"]
+        self.log_level = config_data["log_level"]
+        self.claude_args = config_data["claude_args"]
+        self.launch_method = config_data["launch_method"]
+        self.enable_websocket = config_data["enable_websocket"]
+        self.websocket_port = config_data["websocket_port"]
+        self.use_native_agents = config_data.get("use_native_agents", False)
+        self.config = config_data["config"]
+
+        # Initialize project logger using the service
+        self.project_logger = self.configuration_service.initialize_project_logger(
+            self.log_level
+        )
+
+        # Initialize services using dependency injection and configuration service
+        user_working_dir = self.configuration_service.get_user_working_directory()
+
+        # Register core services
+        self.configuration_service.register_core_services(container, user_working_dir)
+
+        try:
+            self.deployment_service = container.get(AgentDeploymentInterface)
+        except Exception as e:
+            self.logger.error("Failed to resolve AgentDeploymentService", exc_info=True)
+            raise RuntimeError(
+                f"Agent deployment service initialization failed: {e}"
+            ) from e
+
+        # Ticket manager disabled - use claude-mpm tickets CLI commands instead
+        self.ticket_manager = None
+        self.enable_tickets = False
+
+        # Initialize response logger using configuration service
+        self.response_logger = self.configuration_service.initialize_response_logger(
+            self.config, self.project_logger
+        )
+
+        # Initialize hook service using configuration service
+        self.hook_service = self.configuration_service.register_hook_service(
+            container, self.config
+        )
+
+        # Initialize memory hook service using configuration service
+        self.memory_hook_service = (
+            self.configuration_service.register_memory_hook_service(
+                container, self.hook_service
+            )
+        )
+        if self.memory_hook_service:
+            self.memory_hook_service.register_memory_hooks()
+
+        # Initialize agent capabilities service using configuration service
+        self.agent_capabilities_service = (
+            self.configuration_service.register_agent_capabilities_service(container)
+        )
+
+        # Initialize system instructions service using configuration service
+        self.system_instructions_service = (
+            self.configuration_service.register_system_instructions_service(
+                container, self.agent_capabilities_service
+            )
+        )
+
+        # Initialize Socket.IO server reference first
+        self.websocket_server = None
+
+        # Initialize subprocess launcher service using configuration service
+        self.subprocess_launcher_service = (
+            self.configuration_service.register_subprocess_launcher_service(
+                container, self.project_logger, self.websocket_server
+            )
+        )
+
+        # Initialize version service using configuration service
+        self.version_service = self.configuration_service.register_version_service(
+            container
+        )
+
+        # Initialize command handler service using configuration service
+        self.command_handler_service = (
+            self.configuration_service.register_command_handler_service(
+                container, self.project_logger
+            )
+        )
+
+        # Initialize session management service using configuration service
+        # Note: This must be done after other services are initialized since it depends on the runner
+        self.session_management_service = (
+            self.configuration_service.register_session_management_service(
+                container, self
+            )
+        )
+
+        # Initialize utility service using configuration service
+        self.utility_service = self.configuration_service.register_utility_service(
+            container
+        )
+
+        # Load system instructions using the service
+        if self.system_instructions_service:
+            self.system_instructions = (
+                self.system_instructions_service.load_system_instructions()
+            )
+        else:
+            self.system_instructions = self._load_system_instructions()
+
+        # Deploy output style early (before Claude Code launches)
+        # This ensures the "Claude MPM" output style is active on startup
+        self._deploy_output_style()
+
+        # Create session log file using configuration service
+        self.session_log_file = self.configuration_service.create_session_log_file(
+            self.project_logger, self.log_level, config_data
+        )
+
+        # Log session start event if we have a session log file
+        if self.session_log_file:
+            self._log_session_event(
+                {
                     "event": "session_start",
                     "runner": "ClaudeRunner",
-                    "enable_tickets": enable_tickets,
-                    "log_level": log_level,
-                    "launch_method": launch_method
-                })
-            except Exception as e:
-                self.logger.debug(f"Failed to create session log file: {e}")
-        
-        # Initialize Socket.IO server reference
-        self.websocket_server = None
-    
+                    "enable_tickets": self.enable_tickets,
+                    "log_level": self.log_level,
+                    "launch_method": self.launch_method,
+                }
+            )
+
     def setup_agents(self) -> bool:
         """Deploy native agents to .claude/agents/."""
         try:
             if self.project_logger:
                 self.project_logger.log_system(
-                    "Starting agent deployment",
-                    level="INFO",
-                    component="deployment"
+                    "Starting agent deployment", level="INFO", component="deployment"
                 )
-            
+
             results = self.deployment_service.deploy_agents()
-            
+
             if results["deployed"] or results.get("updated", []):
-                deployed_count = len(results['deployed'])
-                updated_count = len(results.get('updated', []))
-                
+                deployed_count = len(results["deployed"])
+                updated_count = len(results.get("updated", []))
+
                 if deployed_count > 0:
                     print(f"✓ Deployed {deployed_count} native agents")
                 if updated_count > 0:
                     print(f"✓ Updated {updated_count} agents")
-                
+
                 if self.project_logger:
                     self.project_logger.log_system(
                         f"Agent deployment successful: {deployed_count} deployed, {updated_count} updated",
                         level="INFO",
-                        component="deployment"
+                        component="deployment",
                     )
-                    
+
                 # Set Claude environment
                 self.deployment_service.set_claude_environment()
                 return True
-            else:
-                self.logger.info("All agents already up to date")
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        "All agents already up to date",
-                        level="INFO",
-                        component="deployment"
-                    )
-                return True
-                
-        except Exception as e:
-            self.logger.error(f"Agent deployment failed: {e}")
-            print(f"⚠️  Agent deployment failed: {e}")
+            self.logger.info("All agents already up to date")
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Agent deployment failed: {e}",
-                    level="ERROR",
-                    component="deployment"
+                    "All agents already up to date",
+                    level="INFO",
+                    component="deployment",
+                )
+            return True
+
+        except PermissionError as e:
+            error_msg = f"Permission denied deploying agents to .claude/agents/: {e}"
+            self.logger.error(error_msg)
+            print(f"❌ {error_msg}")
+            print(
+                "💡 Try running with appropriate permissions or check directory ownership"
+            )
+            if self.project_logger:
+                self.project_logger.log_system(
+                    error_msg, level="ERROR", component="deployment"
                 )
             return False
-    
-    def run_interactive(self, initial_context: Optional[str] = None):
-        """Run Claude in interactive mode."""
-        # Connect to Socket.IO server if enabled
-        if self.enable_websocket:
-            try:
-                # Use Socket.IO client proxy to connect to monitoring server
-                from claude_mpm.services.socketio_server import SocketIOClientProxy
-                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
-                self.websocket_server.start()
-                self.logger.info("Connected to Socket.IO monitoring server")
-                
-                # Generate session ID
-                session_id = str(uuid.uuid4())
-                working_dir = os.getcwd()
-                
-                # Notify session start
-                self.websocket_server.session_started(
-                    session_id=session_id,
-                    launch_method=self.launch_method,
-                    working_dir=working_dir
+
+        except FileNotFoundError as e:
+            error_msg = f"Agent files not found: {e}"
+            self.logger.error(error_msg)
+            print(f"❌ {error_msg}")
+            print("💡 Ensure claude-mpm is properly installed")
+            if self.project_logger:
+                self.project_logger.log_system(
+                    error_msg, level="ERROR", component="deployment"
                 )
-            except Exception as e:
-                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
-                self.websocket_server = None
-        
-        # Get version with robust fallback mechanisms
-        version_str = self._get_version()
-        
-        # Print styled welcome box
-        print("\033[32m╭───────────────────────────────────────────────────╮\033[0m")
-        print("\033[32m│\033[0m ✻ Claude MPM - Interactive Session                \033[32m│\033[0m")
-        print(f"\033[32m│\033[0m   Version {version_str:<40}\033[32m│\033[0m")
-        print("\033[32m│                                                   │\033[0m")
-        print("\033[32m│\033[0m   Type '/agents' to see available agents          \033[32m│\033[0m")
-        print("\033[32m╰───────────────────────────────────────────────────╯\033[0m")
-        print("")  # Add blank line after box
-        
-        if self.project_logger:
-            self.project_logger.log_system(
-                "Starting interactive session",
-                level="INFO",
-                component="session"
-            )
-        
-        # Setup agents
-        if not self.setup_agents():
-            print("Continuing without native agents...")
-        
-        # Build command with system instructions
-        cmd = [
-            "claude",
-            "--model", "opus", 
-            "--dangerously-skip-permissions"
-        ]
-        
-        # Add any custom Claude arguments
-        if self.claude_args:
-            cmd.extend(self.claude_args)
-        
-        # Add system instructions if available
-        system_prompt = self._create_system_prompt()
-        if system_prompt and system_prompt != create_simple_context():
-            cmd.extend(["--append-system-prompt", system_prompt])
-        
-        # Run interactive Claude directly
+            return False
+
+        except ImportError as e:
+            error_msg = f"Missing required module for agent deployment: {e}"
+            self.logger.error(error_msg)
+            print(f"⚠️  {error_msg}")
+            print("💡 Some agent features may be limited")
+            if self.project_logger:
+                self.project_logger.log_system(
+                    error_msg, level="WARNING", component="deployment"
+                )
+            return False
+
+        except Exception as e:
+            error_msg = f"Unexpected error during agent deployment: {e}"
+            self.logger.error(error_msg)
+            print(f"⚠️  {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(
+                    error_msg, level="ERROR", component="deployment"
+                )
+            # Continue without agents rather than failing completely
+            return False
+
+    def ensure_project_agents(self) -> bool:
+        """Ensure system agents are available in the project directory.
+
+        Deploys system agents to project's .claude/agents/ directory
+        if they don't exist or are outdated. This ensures agents are
+        available for Claude Code to use. Project-specific JSON templates
+        should be placed in .claude-mpm/agents/.
+
+        Returns:
+            bool: True if agents are available, False on error
+        """
         try:
-            # Use execvp to replace the current process with Claude
-            # This should avoid any subprocess issues
-            
-            # Clean environment
-            clean_env = os.environ.copy()
-            claude_vars_to_remove = [
-                'CLAUDE_CODE_ENTRYPOINT', 'CLAUDECODE', 'CLAUDE_CONFIG_DIR',
-                'CLAUDE_MAX_PARALLEL_SUBAGENTS', 'CLAUDE_TIMEOUT'
-            ]
-            for var in claude_vars_to_remove:
-                clean_env.pop(var, None)
-            
-            # Set the correct working directory for Claude Code
-            # If CLAUDE_MPM_USER_PWD is set, use that as the working directory
-            if 'CLAUDE_MPM_USER_PWD' in clean_env:
-                user_pwd = clean_env['CLAUDE_MPM_USER_PWD']
-                clean_env['CLAUDE_WORKSPACE'] = user_pwd
-                # Also change to that directory before launching Claude
-                try:
-                    os.chdir(user_pwd)
-                    self.logger.info(f"Changed working directory to: {user_pwd}")
-                except Exception as e:
-                    self.logger.warning(f"Could not change to user directory {user_pwd}: {e}")
-            
-            print("Launching Claude...")
-            
+            # Use the correct user directory, not the framework directory
+            if "CLAUDE_MPM_USER_PWD" in os.environ:
+                project_dir = Path(os.environ["CLAUDE_MPM_USER_PWD"])
+            else:
+                project_dir = Path.cwd()
+
+            project_agents_dir = project_dir / ".claude-mpm" / "agents"
+
+            # Create directory if it doesn't exist
+            project_agents_dir.mkdir(parents=True, exist_ok=True)
+
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Launching Claude interactive mode with {self.launch_method}",
+                    f"Ensuring agents are available in project: {project_agents_dir}",
                     level="INFO",
-                    component="session"
+                    component="deployment",
                 )
-                self._log_session_event({
-                    "event": "launching_claude_interactive",
-                    "command": " ".join(cmd),
-                    "method": self.launch_method
-                })
-            
-            # Notify WebSocket clients
-            if self.websocket_server:
-                self.websocket_server.claude_status_changed(
-                    status="starting",
-                    message="Launching Claude interactive session"
+
+            # Deploy agents to project's .claude/agents directory (not .claude-mpm)
+            # This ensures all system agents are deployed regardless of version
+            # .claude-mpm/agents/ should only contain JSON source templates
+            # .claude/agents/ should contain the built MD files for Claude Code
+            results = self.deployment_service.deploy_agents(
+                target_dir=project_dir / ".claude",
+                force_rebuild=False,
+                deployment_mode="project",
+            )
+
+            if results["deployed"] or results.get("updated", []):
+                deployed_count = len(results["deployed"])
+                updated_count = len(results.get("updated", []))
+
+                if deployed_count > 0:
+                    self.logger.info(f"Deployed {deployed_count} agents to project")
+                if updated_count > 0:
+                    self.logger.info(f"Updated {updated_count} agents in project")
+
+                return True
+            if results.get("skipped", []):
+                # Agents already exist and are current
+                self.logger.debug(
+                    f"Project agents up to date: {len(results['skipped'])} agents"
                 )
-            
-            # Launch using selected method
-            if self.launch_method == "subprocess":
-                self._launch_subprocess_interactive(cmd, clean_env)
-            else:
-                # Default to exec for backward compatibility
-                if self.websocket_server:
-                    # Notify before exec (we won't be able to after)
-                    self.websocket_server.claude_status_changed(
-                        status="running",
-                        message="Claude process started (exec mode)"
-                    )
-                os.execvpe(cmd[0], cmd, clean_env)
-            
+                return True
+            self.logger.warning("No agents deployed to project")
+            return False
+
         except Exception as e:
-            print(f"Failed to launch Claude: {e}")
+            self.logger.error(f"Failed to ensure project agents: {e}")
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Failed to launch Claude: {e}",
+                    f"Failed to ensure project agents: {e}",
                     level="ERROR",
-                    component="session"
-                )
-                self._log_session_event({
-                    "event": "interactive_launch_failed",
-                    "error": str(e),
-                    "exception_type": type(e).__name__
-                })
-            
-            # Notify WebSocket clients of error
-            if self.websocket_server:
-                self.websocket_server.claude_status_changed(
-                    status="error",
-                    message=f"Failed to launch Claude: {e}"
+                    component="deployment",
                 )
-            # Fallback to subprocess
-            try:
-                # Use the same clean_env we prepared earlier
-                subprocess.run(cmd, stdin=None, stdout=None, stderr=None, env=clean_env)
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        "Interactive session completed (subprocess fallback)",
-                        level="INFO",
-                        component="session"
-                    )
-                    self._log_session_event({
-                        "event": "interactive_session_complete",
-                        "fallback": True
-                    })
-            except Exception as fallback_error:
-                print(f"Fallback also failed: {fallback_error}")
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        f"Fallback launch failed: {fallback_error}",
-                        level="ERROR",
-                        component="session"
-                    )
-                    self._log_session_event({
-                        "event": "interactive_fallback_failed",
-                        "error": str(fallback_error),
-                        "exception_type": type(fallback_error).__name__
-                    })
-    
-    def run_oneshot(self, prompt: str, context: Optional[str] = None) -> bool:
-        """Run Claude with a single prompt and return success status."""
-        start_time = time.time()
-        
-        # Connect to Socket.IO server if enabled
-        if self.enable_websocket:
-            try:
-                # Use Socket.IO client proxy to connect to monitoring server
-                from claude_mpm.services.socketio_server import SocketIOClientProxy
-                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
-                self.websocket_server.start()
-                self.logger.info("Connected to Socket.IO monitoring server")
-                
-                # Generate session ID
-                session_id = str(uuid.uuid4())
-                working_dir = os.getcwd()
-                
-                # Notify session start
-                self.websocket_server.session_started(
-                    session_id=session_id,
-                    launch_method="oneshot",
-                    working_dir=working_dir
-                )
-            except Exception as e:
-                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
-                self.websocket_server = None
-        
-        # Check for /mpm: commands
-        if prompt.strip().startswith("/mpm:"):
-            return self._handle_mpm_command(prompt.strip())
-        
-        if self.project_logger:
-            self.project_logger.log_system(
-                f"Starting non-interactive session with prompt: {prompt[:100]}",
-                level="INFO",
-                component="session"
-            )
-        
-        # Setup agents
-        if not self.setup_agents():
-            print("Continuing without native agents...")
-        
-        # Combine context and prompt
-        full_prompt = prompt
-        if context:
-            full_prompt = f"{context}\n\n{prompt}"
-        
-        # Build command with system instructions
-        cmd = [
-            "claude",
-            "--model", "opus",
-            "--dangerously-skip-permissions"
-        ]
-        
-        # Add any custom Claude arguments
-        if self.claude_args:
-            cmd.extend(self.claude_args)
-        
-        # Add print and prompt
-        cmd.extend(["--print", full_prompt])
-        
-        # Add system instructions if available
-        system_prompt = self._create_system_prompt()
-        if system_prompt and system_prompt != create_simple_context():
-            # Insert system prompt before the user prompt
-            cmd.insert(-2, "--append-system-prompt")
-            cmd.insert(-2, system_prompt)
-        
+            return False
+
+    def deploy_project_agents_to_claude(self) -> bool:
+        """Deploy project agents from .claude-mpm/agents/ to .claude/agents/.
+
+        This method handles the deployment of project-specific agents (JSON format)
+        from the project's agents directory to Claude's agent directory.
+        Project agents take precedence over system agents.
+
+        WHY: Project agents allow teams to define custom, project-specific agents
+        that override system agents. These are stored in JSON format in
+        .claude-mpm/agents/ and need to be deployed to .claude/agents/
+        as MD files for Claude to use them.
+
+        Returns:
+            bool: True if deployment successful or no agents to deploy, False on error
+        """
         try:
-            # Set up environment with correct working directory
-            env = os.environ.copy()
-            
-            # Set the correct working directory for Claude Code
-            if 'CLAUDE_MPM_USER_PWD' in env:
-                user_pwd = env['CLAUDE_MPM_USER_PWD']
-                env['CLAUDE_WORKSPACE'] = user_pwd
-                # Change to that directory before running Claude
-                try:
-                    original_cwd = os.getcwd()
-                    os.chdir(user_pwd)
-                    self.logger.info(f"Changed working directory to: {user_pwd}")
-                except Exception as e:
-                    self.logger.warning(f"Could not change to user directory {user_pwd}: {e}")
-                    original_cwd = None
+            # Use the correct user directory, not the framework directory
+            if "CLAUDE_MPM_USER_PWD" in os.environ:
+                project_dir = Path(os.environ["CLAUDE_MPM_USER_PWD"])
             else:
-                original_cwd = None
-            
-            # Run Claude
+                project_dir = Path.cwd()
+
+            project_agents_dir = project_dir / ".claude-mpm" / "agents"
+            claude_agents_dir = project_dir / ".claude" / "agents"
+
+            # Check if project agents directory exists
+            if not project_agents_dir.exists():
+                self.logger.debug("No project agents directory found")
+                return True  # Not an error - just no project agents
+
+            # Get JSON agent files from agents directory
+            json_files = list(project_agents_dir.glob("*.json"))
+            if not json_files:
+                self.logger.debug("No JSON agents in project")
+                return True
+
+            # Create .claude/agents directory if needed
+            claude_agents_dir.mkdir(parents=True, exist_ok=True)
+
+            self.logger.info(
+                f"Deploying {len(json_files)} project agents to .claude/agents/"
+            )
             if self.project_logger:
                 self.project_logger.log_system(
-                    "Executing Claude subprocess",
+                    f"Deploying project agents from {project_agents_dir} to {claude_agents_dir}",
                     level="INFO",
-                    component="session"
-                )
-            
-            # Notify WebSocket clients
-            if self.websocket_server:
-                self.websocket_server.claude_status_changed(
-                    status="running",
-                    message="Executing Claude oneshot command"
+                    component="deployment",
                 )
-            
-            result = subprocess.run(cmd, capture_output=True, text=True, env=env)
-            
-            # Restore original directory if we changed it
-            if original_cwd:
+
+            deployed_count = 0
+            updated_count = 0
+            errors = []
+
+            # Deploy each JSON agent
+            # CRITICAL: PM (Project Manager) must NEVER be deployed as it's the main Claude instance
+            EXCLUDED_AGENTS = {"pm", "project_manager"}
+
+            # Initialize deployment service with proper base agent path
+            # Use the existing deployment service's base agent path if available
+            base_agent_path = project_agents_dir / "base_agent.json"
+            if not base_agent_path.exists():
+                # Fall back to system base agent
+                base_agent_path = self.deployment_service.base_agent_path
+
+            # Lazy import to avoid circular dependencies
+            from claude_mpm.services.agents.deployment import AgentDeploymentService
+
+            # Create a single deployment service instance for all agents
+            project_deployment = AgentDeploymentService(
+                templates_dir=project_agents_dir,
+                base_agent_path=base_agent_path,
+                working_directory=project_dir,  # Pass the project directory
+            )
+
+            # Load base agent data once
+            base_agent_data = {}
+            if base_agent_path and base_agent_path.exists():
                 try:
-                    os.chdir(original_cwd)
-                except Exception:
-                    pass
-            execution_time = time.time() - start_time
-            
-            if result.returncode == 0:
-                response = result.stdout.strip()
-                print(response)
-                
-                # Broadcast output to WebSocket clients
-                if self.websocket_server and response:
-                    self.websocket_server.claude_output(response, "stdout")
-                
-                if self.project_logger:
-                    # Log successful completion
-                    self.project_logger.log_system(
-                        f"Non-interactive session completed successfully in {execution_time:.2f}s",
-                        level="INFO",
-                        component="session"
-                    )
-                    
-                    # Log session event
-                    self._log_session_event({
-                        "event": "session_complete",
-                        "success": True,
-                        "execution_time": execution_time,
-                        "response_length": len(response)
-                    })
-                    
-                    # Log agent invocation if we detect delegation patterns
-                    if self._contains_delegation(response):
-                        self.project_logger.log_system(
-                            "Detected potential agent delegation in response",
-                            level="INFO",
-                            component="delegation"
+                    import json
+
+                    base_agent_data = json.loads(base_agent_path.read_text())
+                except Exception as e:
+                    self.logger.warning(f"Could not load base agent: {e}")
+
+            for json_file in json_files:
+                try:
+                    agent_name = json_file.stem
+
+                    # Skip PM agent - it's the main Claude instance, not a subagent
+                    if agent_name.lower() in EXCLUDED_AGENTS:
+                        self.logger.info(
+                            f"Skipping {agent_name} (PM is the main Claude instance)"
                         )
-                        self._log_session_event({
-                            "event": "delegation_detected",
-                            "prompt": prompt[:200],
-                            "indicators": [p for p in ["Task(", "subagent_type=", "engineer agent", "qa agent"] 
-                                          if p.lower() in response.lower()]
-                        })
-                        
-                        # Notify WebSocket clients about delegation
-                        if self.websocket_server:
-                            # Try to extract agent name
-                            agent_name = self._extract_agent_from_response(response)
-                            if agent_name:
-                                self.websocket_server.agent_delegated(
-                                    agent=agent_name,
-                                    task=prompt[:100],
-                                    status="detected"
-                                )
-                
-                # Extract tickets if enabled
-                if self.enable_tickets and self.ticket_manager and response:
-                    self._extract_tickets(response)
-                
-                return True
-            else:
-                error_msg = result.stderr or "Unknown error"
-                print(f"Error: {error_msg}")
-                
-                # Broadcast error to WebSocket clients
-                if self.websocket_server:
-                    self.websocket_server.claude_output(error_msg, "stderr")
-                    self.websocket_server.claude_status_changed(
-                        status="error",
-                        message=f"Command failed with code {result.returncode}"
-                    )
-                
+                        continue
+
+                    target_file = claude_agents_dir / f"{agent_name}.md"
+
+                    # Check if agent needs update
+                    needs_update = True
+                    if target_file.exists():
+                        # Check if it's a project agent (has project marker)
+                        existing_content = target_file.read_text()
+                        if (
+                            "author: claude-mpm-project" in existing_content
+                            or "source: project" in existing_content
+                        ) and target_file.stat().st_mtime >= json_file.stat().st_mtime:
+                            needs_update = False
+                            self.logger.debug(
+                                f"Project agent {agent_name} is up to date"
+                            )
+
+                    if needs_update:
+                        # Build the agent markdown using the pre-initialized service and base agent data
+                        # Use template_builder service instead of removed _build_agent_markdown method
+                        agent_content = (
+                            project_deployment.template_builder.build_agent_markdown(
+                                agent_name,
+                                json_file,
+                                base_agent_data,
+                                source_info="project",
+                            )
+                        )
+
+                        # Mark as project agent
+                        agent_content = agent_content.replace(
+                            "author: claude-mpm", "author: claude-mpm-project"
+                        )
+
+                        # Write the agent file
+                        is_update = target_file.exists()
+                        target_file.write_text(agent_content)
+
+                        if is_update:
+                            updated_count += 1
+                            self.logger.info(f"Updated project agent: {agent_name}")
+                        else:
+                            deployed_count += 1
+                            self.logger.info(f"Deployed project agent: {agent_name}")
+
+                except Exception as e:
+                    error_msg = f"Failed to deploy project agent {json_file.name}: {e}"
+                    self.logger.error(error_msg)
+                    errors.append(error_msg)
+
+            # Report results
+            if deployed_count > 0 or updated_count > 0:
+                print(
+                    f"✓ Deployed {deployed_count} project agents, updated {updated_count}"
+                )
                 if self.project_logger:
                     self.project_logger.log_system(
-                        f"Non-interactive session failed: {error_msg}",
-                        level="ERROR",
-                        component="session"
+                        f"Project agent deployment: {deployed_count} deployed, {updated_count} updated",
+                        level="INFO",
+                        component="deployment",
                     )
-                    self._log_session_event({
-                        "event": "session_failed",
-                        "success": False,
-                        "error": error_msg,
-                        "return_code": result.returncode
-                    })
-                
+
+            if errors:
+                for error in errors:
+                    print(f"⚠️  {error}")
                 return False
-                
+
+            return True
+
         except Exception as e:
-            print(f"Error: {e}")
-            
+            error_msg = f"Failed to deploy project agents: {e}"
+            self.logger.error(error_msg)
+            print(f"⚠️  {error_msg}")
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Exception during non-interactive session: {e}",
-                    level="ERROR",
-                    component="session"
+                    error_msg, level="ERROR", component="deployment"
                 )
-                self._log_session_event({
-                    "event": "session_exception",
-                    "success": False,
-                    "exception": str(e),
-                    "exception_type": type(e).__name__
-                })
-            
             return False
-        finally:
-            # Ensure logs are flushed
-            if self.project_logger:
-                try:
-                    # Log session summary
-                    summary = self.project_logger.get_session_summary()
-                    self.project_logger.log_system(
-                        f"Session {summary['session_id']} completed",
-                        level="INFO",
-                        component="session"
-                    )
-                except Exception as e:
-                    self.logger.debug(f"Failed to log session summary: {e}")
-            
-            # End WebSocket session
-            if self.websocket_server:
-                self.websocket_server.claude_status_changed(
-                    status="stopped",
-                    message="Session completed"
-                )
-                self.websocket_server.session_ended()
-    
+
+    def run_interactive(self, initial_context: Optional[str] = None):
+        """Run Claude in interactive mode using the session management service.
+
+        Delegates to the SessionManagementService for session orchestration.
+
+        Args:
+            initial_context: Optional initial context to pass to Claude
+        """
+        if self.session_management_service:
+            self.session_management_service.run_interactive_session(initial_context)
+        else:
+            self.logger.error("Session management service not available")
+            print("Error: Session management service not available")
+
+    def run_oneshot(self, prompt: str, context: Optional[str] = None) -> bool:
+        """Run Claude with a single prompt using the session management service.
+
+        Delegates to the SessionManagementService for session orchestration.
+
+        Args:
+            prompt: The command or prompt to execute
+            context: Optional context to prepend to the prompt
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        if self.session_management_service:
+            return self.session_management_service.run_oneshot_session(prompt, context)
+        self.logger.error("Session management service not available")
+        print("Error: Session management service not available")
+        return False
+
     def _extract_tickets(self, text: str):
-        """Extract tickets from Claude's response."""
-        if not self.ticket_manager:
-            return
-            
-        try:
-            # Use the ticket manager's extraction logic if available
-            if hasattr(self.ticket_manager, 'extract_tickets_from_text'):
-                tickets = self.ticket_manager.extract_tickets_from_text(text)
-                if tickets:
-                    print(f"\n📋 Extracted {len(tickets)} tickets")
-                    for ticket in tickets[:3]:  # Show first 3
-                        print(f"  - [{ticket.get('id', 'N/A')}] {ticket.get('title', 'No title')}")
-                    if len(tickets) > 3:
-                        print(f"  ... and {len(tickets) - 3} more")
-            else:
-                self.logger.debug("Ticket extraction method not available")
-        except Exception as e:
-            self.logger.debug(f"Ticket extraction failed: {e}")
+        """Extract tickets from Claude's response (disabled - use claude-mpm tickets CLI)."""
+        # Ticket extraction disabled - users should use claude-mpm tickets CLI commands
 
     def _load_system_instructions(self) -> Optional[str]:
-        """Load and process system instructions from agents/INSTRUCTIONS.md.
-        
-        WHY: Process template variables like {{capabilities-list}} to include
-        dynamic agent capabilities in the PM's system instructions.
+        """Load and process system instructions.
+
+        Delegates to the SystemInstructionsService for loading and processing.
         """
-        try:
-            # Find the INSTRUCTIONS.md file
-            module_path = Path(__file__).parent.parent
-            instructions_path = module_path / "agents" / "INSTRUCTIONS.md"
-            
-            if not instructions_path.exists():
-                self.logger.warning(f"System instructions not found: {instructions_path}")
-                return None
-            
-            # Read raw instructions
-            raw_instructions = instructions_path.read_text()
-            
-            # Process template variables if ContentAssembler is available
-            try:
-                from claude_mpm.services.framework_claude_md_generator.content_assembler import ContentAssembler
-                assembler = ContentAssembler()
-                processed_instructions = assembler.apply_template_variables(raw_instructions)
-                self.logger.info("Loaded and processed PM framework system instructions with dynamic capabilities")
-                return processed_instructions
-            except ImportError:
-                self.logger.warning("ContentAssembler not available, using raw instructions")
-                return raw_instructions
-            except Exception as e:
-                self.logger.warning(f"Failed to process template variables: {e}, using raw instructions")
-                return raw_instructions
-            
-        except Exception as e:
-            self.logger.error(f"Failed to load system instructions: {e}")
-            return None
+        if self.system_instructions_service:
+            return self.system_instructions_service.load_system_instructions()
+        # Fallback if service is not available
+        self.logger.warning(
+            "System instructions service not available, using basic fallback"
+        )
+        return None
+
+    def _process_base_pm_content(self, base_pm_content: str) -> str:
+        """Process BASE_PM.md content with dynamic injections.
+
+        Delegates to the SystemInstructionsService for processing.
+        """
+        if self.system_instructions_service:
+            return self.system_instructions_service.process_base_pm_content(
+                base_pm_content
+            )
+        # Fallback if service is not available
+        self.logger.warning(
+            "System instructions service not available for BASE_PM processing"
+        )
+        return base_pm_content
+
+    def _strip_metadata_comments(self, content: str) -> str:
+        """Strip HTML metadata comments from content.
+
+        Delegates to the SystemInstructionsService for processing.
+        """
+        if self.system_instructions_service:
+            return self.system_instructions_service.strip_metadata_comments(content)
+        # Fallback if service is not available
+        self.logger.warning(
+            "System instructions service not available for metadata stripping"
+        )
+        return content
+
+    def _generate_deployed_agent_capabilities(self) -> str:
+        """Generate agent capabilities from deployed agents.
+
+        Delegates to the AgentCapabilitiesService for agent discovery and formatting.
+        """
+        if self.agent_capabilities_service:
+            return (
+                self.agent_capabilities_service.generate_deployed_agent_capabilities()
+            )
+        # Fallback if service is not available
+        self.logger.warning("Agent capabilities service not available, using fallback")
+        return self._get_fallback_capabilities()
+
+    def _get_fallback_capabilities(self) -> str:
+        """Return fallback agent capabilities when deployed agents can't be read."""
+        # Delegate to the service if available, otherwise use basic fallback
+        if self.agent_capabilities_service:
+            return self.agent_capabilities_service._get_fallback_capabilities()
+        return """
+## Available Agent Capabilities
+
+You have the following specialized agents available for delegation:
+
+- **Engineer Agent**: Code implementation and development
+- **Research Agent**: Investigation and analysis
+- **QA Agent**: Testing and quality assurance
+- **Documentation Agent**: Documentation creation and maintenance
+
+Use these agents to delegate specialized work via the Task tool.
+"""
 
     def _create_system_prompt(self) -> str:
-        """Create the complete system prompt including instructions."""
+        """Create the complete system prompt including instructions.
+
+        Delegates to the SystemInstructionsService for prompt creation.
+        """
+        if self.system_instructions_service:
+            return self.system_instructions_service.create_system_prompt(
+                self.system_instructions
+            )
+        # Fallback if service is not available
         if self.system_instructions:
             return self.system_instructions
-        else:
-            # Fallback to basic context
-            return create_simple_context()
-    
+        return create_simple_context()
+
     def _contains_delegation(self, text: str) -> bool:
-        """Check if text contains signs of agent delegation."""
-        # Look for common delegation patterns
-        delegation_patterns = [
-            "Task(",
-            "subagent_type=",
-            "delegating to",
-            "asking the",
-            "engineer agent",
-            "qa agent",
-            "documentation agent",
-            "research agent",
-            "security agent",
-            "ops agent",
-            "version_control agent",
-            "data_engineer agent"
-        ]
-        
-        text_lower = text.lower()
-        return any(pattern.lower() in text_lower for pattern in delegation_patterns)
-    
+        """Check if text contains signs of agent delegation using the utility service."""
+        if self.utility_service:
+            return self.utility_service.contains_delegation(text)
+        # Fallback if service not available
+        return False
+
     def _extract_agent_from_response(self, text: str) -> Optional[str]:
-        """Try to extract agent name from delegation response."""
-        # Look for common patterns
-        import re
-        
-        # Pattern 1: subagent_type="agent_name"
-        match = re.search(r'subagent_type=["\']([^"\']*)["\'\)]', text)
-        if match:
-            return match.group(1)
-        
-        # Pattern 2: "engineer agent" etc
-        agent_names = [
-            "engineer", "qa", "documentation", "research", 
-            "security", "ops", "version_control", "data_engineer"
-        ]
-        text_lower = text.lower()
-        for agent in agent_names:
-            if f"{agent} agent" in text_lower or f"agent: {agent}" in text_lower:
-                return agent
-        
+        """Try to extract agent name from delegation response using the utility service."""
+        if self.utility_service:
+            return self.utility_service.extract_agent_from_response(text)
+        # Fallback if service not available
         return None
-    
+
     def _handle_mpm_command(self, prompt: str) -> bool:
-        """Handle /mpm: commands directly without going to Claude."""
-        try:
-            # Extract command and arguments
-            command_line = prompt[5:].strip()  # Remove "/mpm:"
-            parts = command_line.split()
-            
-            if not parts:
-                print("No command specified. Available commands: test")
-                return True
-            
-            command = parts[0]
-            args = parts[1:]
-            
-            # Handle commands
-            if command == "test":
-                print("Hello World")
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        "Executed /mpm:test command",
-                        level="INFO",
-                        component="command"
-                    )
-                return True
-            elif command == "agents":
-                # Handle agents command - display deployed agent versions
-                # WHY: This provides users with a quick way to check deployed agent versions
-                # directly from within Claude Code, maintaining consistency with CLI behavior
-                try:
-                    from claude_mpm.cli import _get_agent_versions_display
-                    agent_versions = _get_agent_versions_display()
-                    if agent_versions:
-                        print(agent_versions)
-                    else:
-                        print("No deployed agents found")
-                        print("\nTo deploy agents, run: claude-mpm --mpm:agents deploy")
-                    
-                    if self.project_logger:
-                        self.project_logger.log_system(
-                            "Executed /mpm:agents command",
-                            level="INFO",
-                            component="command"
-                        )
-                    return True
-                except Exception as e:
-                    print(f"Error getting agent versions: {e}")
-                    return False
-            else:
-                print(f"Unknown command: {command}")
-                print("Available commands: test, agents")
-                return True
-                
-        except Exception as e:
-            print(f"Error executing command: {e}")
-            if self.project_logger:
-                self.project_logger.log_system(
-                    f"Failed to execute /mpm: command: {e}",
-                    level="ERROR",
-                    component="command"
-                )
-            return False
-    
+        """Handle /mpm: commands using the command handler service.
+
+        Delegates to the CommandHandlerService for command processing.
+        """
+        if self.command_handler_service:
+            return self.command_handler_service.handle_mpm_command(prompt)
+        # Fallback if service not available
+        print("Command handler service not available")
+        return False
+
     def _log_session_event(self, event_data: dict):
-        """Log an event to the session log file."""
-        if self.session_log_file:
-            try:
-                log_entry = {
-                    "timestamp": datetime.now().isoformat(),
-                    **event_data
-                }
-                
-                with open(self.session_log_file, 'a') as f:
-                    f.write(json.dumps(log_entry) + '\n')
-            except Exception as e:
-                self.logger.debug(f"Failed to log session event: {e}")
-    
+        """Log an event to the session log file using the utility service."""
+        if self.utility_service:
+            self.utility_service.log_session_event(self.session_log_file, event_data)
+        else:
+            # Fallback if service not available
+            self.logger.debug("Utility service not available for session logging")
+
     def _get_version(self) -> str:
+        """Get version string using the version service.
+
+        Delegates to the VersionService for version detection and formatting.
         """
-        Robust version determination with multiple fallback mechanisms.
-        
-        WHY: The version display is critical for debugging and user experience.
-        This implementation ensures we always show the correct version rather than 
-        defaulting to v0.0.0, even in edge cases where imports might fail.
-        
-        DESIGN DECISION: We try multiple methods in order of preference:
-        1. Package import (__version__) - fastest for normal installations
-        2. importlib.metadata - standard for installed packages  
-        3. VERSION file reading - fallback for development environments
-        4. Only then default to v0.0.0 with detailed error logging
-        
-        Returns version string formatted as "vX.Y.Z"
-        """
-        version = "0.0.0"
-        method_used = "default"
-        
-        # Method 1: Try package import (fastest, most common)
-        try:
-            from claude_mpm import __version__
-            version = __version__
-            method_used = "package_import"
-            self.logger.debug(f"Version obtained via package import: {version}")
-        except ImportError as e:
-            self.logger.debug(f"Package import failed: {e}")
-        except Exception as e:
-            self.logger.warning(f"Unexpected error in package import: {e}")
-        
-        # Method 2: Try importlib.metadata (standard for installed packages)
-        if version == "0.0.0":
-            try:
-                import importlib.metadata
-                version = importlib.metadata.version('claude-mpm')
-                method_used = "importlib_metadata"
-                self.logger.debug(f"Version obtained via importlib.metadata: {version}")
-            except importlib.metadata.PackageNotFoundError:
-                self.logger.debug("Package not found in importlib.metadata (likely development install)")
-            except ImportError:
-                self.logger.debug("importlib.metadata not available (Python < 3.8)")
-            except Exception as e:
-                self.logger.warning(f"Unexpected error in importlib.metadata: {e}")
-        
-        # Method 3: Try reading VERSION file directly (development fallback)
-        if version == "0.0.0":
-            try:
-                # Calculate path relative to this file
-                version_file = Path(__file__).parent.parent.parent.parent / "VERSION"
-                if version_file.exists():
-                    version = version_file.read_text().strip()
-                    method_used = "version_file"
-                    self.logger.debug(f"Version obtained via VERSION file: {version}")
-                else:
-                    self.logger.debug(f"VERSION file not found at: {version_file}")
-            except Exception as e:
-                self.logger.warning(f"Failed to read VERSION file: {e}")
-        
-        # Log final result
-        if version == "0.0.0":
-            self.logger.error(
-                "All version detection methods failed. This indicates a packaging or installation issue."
-            )
-        else:
-            self.logger.debug(f"Final version: {version} (method: {method_used})")
-        
-        return f"v{version}"
-    
-    def _register_memory_hooks(self):
-        """Register memory integration hooks with the hook service.
-        
-        WHY: This activates the memory system by registering hooks that automatically
-        inject agent memory before delegation and extract learnings after delegation.
-        This is the critical connection point between the memory system and the CLI.
-        
-        DESIGN DECISION: We register hooks here instead of in __init__ to ensure
-        all services are initialized first. Hooks are only registered if the memory
-        system is enabled in configuration.
+        if self.version_service:
+            return self.version_service.get_version()
+        # Fallback if service not available
+        return "v0.0.0"
+
+    def _deploy_output_style(self) -> None:
+        """Deploy the Claude MPM output style before Claude Code launches.
+
+        This method ensures the output style is set to "Claude MPM" on startup
+        by deploying the style file and updating Claude Code settings.
+        Only works for Claude Code >= 1.0.83.
         """
         try:
-            # Only register if memory system is enabled
-            if not self.config.get('memory.enabled', True):
-                self.logger.debug("Memory system disabled - skipping hook registration")
+            from claude_mpm.core.output_style_manager import OutputStyleManager
+
+            # Create OutputStyleManager instance
+            output_style_manager = OutputStyleManager()
+
+            # Check if Claude Code supports output styles
+            if not output_style_manager.supports_output_styles():
+                self.logger.debug(
+                    f"Claude Code version {output_style_manager.claude_version or 'unknown'} "
+                    "does not support output styles (requires >= 1.0.83)"
+                )
                 return
-            
-            # Import hook classes (lazy import to avoid circular dependencies)
-            from claude_mpm.hooks.memory_integration_hook import (
-                MemoryPreDelegationHook,
-                MemoryPostDelegationHook
+
+            # Check if output style is already deployed and active
+            settings_file = Path.home() / ".claude" / "settings.json"
+            if settings_file.exists():
+                try:
+                    import json
+
+                    settings = json.loads(settings_file.read_text())
+                    if settings.get("activeOutputStyle") == "claude-mpm":
+                        # Already active, check if file exists
+                        output_style_file = (
+                            Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
+                        )
+                        if output_style_file.exists():
+                            self.logger.debug(
+                                "Output style 'Claude MPM' already deployed and active"
+                            )
+                            return
+                except Exception:
+                    pass  # Continue with deployment if we can't read settings
+
+            # Read the OUTPUT_STYLE.md content if it exists
+            output_style_path = (
+                Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
             )
-            
-            # Register pre-delegation hook for memory injection
-            pre_hook = MemoryPreDelegationHook(self.config)
-            success = self.hook_service.register_hook(pre_hook)
-            if success:
-                self.logger.info(f"✅ Registered memory pre-delegation hook (priority: {pre_hook.priority})")
-            else:
-                self.logger.warning("❌ Failed to register memory pre-delegation hook")
-            
-            # Register post-delegation hook if auto-learning is enabled
-            if self.config.get('memory.auto_learning', True):  # Default to True now
-                post_hook = MemoryPostDelegationHook(self.config)
-                success = self.hook_service.register_hook(post_hook)
-                if success:
-                    self.logger.info(f"✅ Registered memory post-delegation hook (priority: {post_hook.priority})")
-                else:
-                    self.logger.warning("❌ Failed to register memory post-delegation hook")
+
+            if output_style_path.exists():
+                # Use existing OUTPUT_STYLE.md content
+                output_style_content = output_style_path.read_text()
+                self.logger.debug("Using existing OUTPUT_STYLE.md content")
             else:
-                self.logger.info("ℹ️  Auto-learning disabled - skipping post-delegation hook")
-            
-            # Log summary of registered hooks
-            hooks = self.hook_service.list_hooks()
-            pre_count = len(hooks.get('pre_delegation', []))
-            post_count = len(hooks.get('post_delegation', []))
-            self.logger.info(f"📋 Hook Service initialized: {pre_count} pre-delegation, {post_count} post-delegation hooks")
-            
-        except Exception as e:
-            self.logger.error(f"❌ Failed to register memory hooks: {e}")
-            # Don't fail the entire initialization - memory system is optional
-    
-    def _launch_subprocess_interactive(self, cmd: list, env: dict):
-        """Launch Claude as a subprocess with PTY for interactive mode."""
-        import pty
-        import select
-        import termios
-        import tty
-        import signal
-        
-        # Save original terminal settings
-        original_tty = None
-        if sys.stdin.isatty():
-            original_tty = termios.tcgetattr(sys.stdin)
-        
-        # Create PTY
-        master_fd, slave_fd = pty.openpty()
-        
-        try:
-            # Start Claude process
-            process = subprocess.Popen(
-                cmd,
-                stdin=slave_fd,
-                stdout=slave_fd,
-                stderr=slave_fd,
-                env=env
-            )
-            
-            # Close slave in parent
-            os.close(slave_fd)
-            
-            if self.project_logger:
-                self.project_logger.log_system(
-                    f"Claude subprocess started with PID {process.pid}",
-                    level="INFO",
-                    component="subprocess"
+                # Extract output style content from framework instructions
+                output_style_content = (
+                    output_style_manager.extract_output_style_content()
                 )
-            
-            # Notify WebSocket clients
-            if self.websocket_server:
-                self.websocket_server.claude_status_changed(
-                    status="running",
-                    pid=process.pid,
-                    message="Claude subprocess started"
+                self.logger.debug("Extracted output style from framework instructions")
+
+            # Deploy the output style
+            deployed = output_style_manager.deploy_output_style(output_style_content)
+
+            if deployed:
+                self.logger.info(
+                    "✅ Output style 'Claude MPM' deployed and activated on startup"
                 )
-            
-            # Set terminal to raw mode for proper interaction
-            if sys.stdin.isatty():
-                tty.setraw(sys.stdin)
-            
-            # Handle Ctrl+C gracefully
-            def signal_handler(signum, frame):
-                if process.poll() is None:
-                    process.terminate()
-                raise KeyboardInterrupt()
-            
-            signal.signal(signal.SIGINT, signal_handler)
-            
-            # I/O loop
-            while True:
-                # Check if process is still running
-                if process.poll() is not None:
-                    break
-                
-                # Check for data from Claude or stdin
-                r, _, _ = select.select([master_fd, sys.stdin], [], [], 0)
-                
-                if master_fd in r:
-                    try:
-                        data = os.read(master_fd, 4096)
-                        if data:
-                            os.write(sys.stdout.fileno(), data)
-                            # Broadcast output to WebSocket clients
-                            if self.websocket_server:
-                                try:
-                                    # Decode and send
-                                    output = data.decode('utf-8', errors='replace')
-                                    self.websocket_server.claude_output(output, "stdout")
-                                except Exception as e:
-                                    self.logger.debug(f"Failed to broadcast output: {e}")
-                        else:
-                            break  # EOF
-                    except OSError:
-                        break
-                
-                if sys.stdin in r:
-                    try:
-                        data = os.read(sys.stdin.fileno(), 4096)
-                        if data:
-                            os.write(master_fd, data)
-                    except OSError:
-                        break
-            
-            # Wait for process to complete
-            process.wait()
-            
+                if self.project_logger:
+                    self.project_logger.log_system(
+                        "Output style 'Claude MPM' deployed and activated on startup",
+                        level="INFO",
+                        component="output_style",
+                    )
+            else:
+                self.logger.warning("Failed to deploy output style")
+
+        except ImportError as e:
+            self.logger.warning(f"Could not import OutputStyleManager: {e}")
+        except Exception as e:
+            # Don't fail startup if output style deployment fails
+            self.logger.warning(f"Error deploying output style: {e}")
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Claude subprocess exited with code {process.returncode}",
-                    level="INFO",
-                    component="subprocess"
-                )
-            
-            # Notify WebSocket clients
-            if self.websocket_server:
-                self.websocket_server.claude_status_changed(
-                    status="stopped",
-                    message=f"Claude subprocess exited with code {process.returncode}"
+                    f"Output style deployment error: {e}",
+                    level="WARNING",
+                    component="output_style",
                 )
-            
-        finally:
-            # Restore terminal
-            if original_tty and sys.stdin.isatty():
-                termios.tcsetattr(sys.stdin, termios.TCSADRAIN, original_tty)
-            
-            # Close PTY
-            try:
-                os.close(master_fd)
-            except:
-                pass
-            
-            # Ensure process is terminated
-            if 'process' in locals() and process.poll() is None:
-                process.terminate()
-                try:
-                    process.wait(timeout=2)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    process.wait()
-            
-            # End WebSocket session if in subprocess mode
-            if self.websocket_server:
-                self.websocket_server.session_ended()
-
-
-def create_simple_context() -> str:
-    """Create basic context for Claude."""
-    return """You are Claude Code running in Claude MPM (Multi-Agent Project Manager).
-
-You have access to native subagents via the Task tool with subagent_type parameter:
-- engineer: For coding, implementation, and technical tasks
-- qa: For testing, validation, and quality assurance  
-- documentation: For docs, guides, and explanations
-- research: For investigation and analysis
-- security: For security-related tasks
-- ops: For deployment and infrastructure
-- version-control: For git and version management
-- data-engineer: For data processing and APIs
-
-Use these agents by calling: Task(description="task description", subagent_type="agent_name")
 
-IMPORTANT: The Task tool accepts both naming formats:
-- Capitalized format: "Research", "Engineer", "QA", "Version Control", "Data Engineer"
-- Lowercase format: "research", "engineer", "qa", "version-control", "data-engineer"
+    def _launch_subprocess_interactive(self, cmd: list, env: dict):
+        """Launch Claude as a subprocess with PTY for interactive mode.
 
-Both formats work correctly. When you see capitalized names (matching TodoWrite prefixes), 
-automatically normalize them to lowercase-hyphenated format for the Task tool.
+        Delegates to the SubprocessLauncherService for subprocess management.
+        """
+        if self.subprocess_launcher_service:
+            self.subprocess_launcher_service.launch_subprocess_interactive(cmd, env)
+        else:
+            # Fallback if service is not available
+            self.logger.warning(
+                "Subprocess launcher service not available, cannot launch subprocess"
+            )
+            raise RuntimeError("Subprocess launcher service not available")
 
-Work efficiently and delegate appropriately to subagents when needed."""
 
+# Moved to claude_mpm.core.system_context to avoid circular imports
+from claude_mpm.core.system_context import create_simple_context
 
 # Backward compatibility alias
 SimpleClaudeRunner = ClaudeRunner
@@ -1043,4 +823,4 @@ def run_claude_oneshot(prompt: str, context: Optional[str] = None) -> bool:
     runner = ClaudeRunner()
     if context is None:
         context = create_simple_context()
-    return runner.run_oneshot(prompt, context)
+    return runner.run_oneshot(prompt, context)