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

claude_mpm/core/framework_loader.py

@@ -1,472 +1,543 @@
-"""Framework loader for Claude MPM."""
+"""Framework loader for Claude MPM - Refactored modular version."""
 
+import asyncio
 import os
-import logging
 from pathlib import Path
-from typing import Optional, Dict, Any
-from datetime import datetime
+from typing import Any, Dict, List, Optional, Set
 
-from ..utils.imports import safe_import
+# Import framework components
+from claude_mpm.core.framework import (
+    AgentLoader,
+    CapabilityGenerator,
+    ContentFormatter,
+    ContextGenerator,
+    FileLoader,
+    InstructionLoader,
+    MemoryProcessor,
+    MetadataProcessor,
+    PackagedLoader,
+    TemplateProcessor,
+)
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.utils.imports import safe_import
 
-# Import with fallback support - using absolute imports as primary since we're at module level
-get_logger = safe_import('claude_mpm.core.logger', 'core.logger', ['get_logger'])
-AgentRegistryAdapter = safe_import('claude_mpm.core.agent_registry', 'core.agent_registry', ['AgentRegistryAdapter'])
+# Import with fallback support
+AgentRegistryAdapter = safe_import(
+    "claude_mpm.core.agent_registry", "core.agent_registry", ["AgentRegistryAdapter"]
+)
+
+# Import API validator
+try:
+    from claude_mpm.core.api_validator import validate_api_keys
+except ImportError:
+    from ..core.api_validator import validate_api_keys
+
+# Import the service container and interfaces
+try:
+    from claude_mpm.services.core.cache_manager import CacheManager
+    from claude_mpm.services.core.memory_manager import MemoryManager
+    from claude_mpm.services.core.path_resolver import PathResolver
+    from claude_mpm.services.core.service_container import (
+        ServiceContainer,
+        get_global_container,
+    )
+    from claude_mpm.services.core.service_interfaces import (
+        ICacheManager,
+        IMemoryManager,
+        IPathResolver,
+    )
+except ImportError:
+    # Fallback for development environments
+    from ..services.core.cache_manager import CacheManager
+    from ..services.core.memory_manager import MemoryManager
+    from ..services.core.path_resolver import PathResolver
+    from ..services.core.service_container import ServiceContainer, get_global_container
+    from ..services.core.service_interfaces import (
+        ICacheManager,
+        IMemoryManager,
+        IPathResolver,
+    )
 
 
 class FrameworkLoader:
     """
     Load and prepare framework instructions for injection.
-    
-    This component handles:
-    1. Finding the framework (claude-multiagent-pm)
-    2. Loading INSTRUCTIONS.md instructions
-    3. Preparing agent definitions
-    4. Formatting for injection
+
+    This refactored version uses modular components for better maintainability
+    and testability while maintaining backward compatibility.
+
+    Components:
+    - Loaders: Handle file I/O and resource loading
+    - Formatters: Generate and format content sections
+    - Processors: Process metadata, templates, and memories
     """
-    
-    def __init__(self, framework_path: Optional[Path] = None, agents_dir: Optional[Path] = None):
+
+    def __init__(
+        self,
+        framework_path: Optional[Path] = None,
+        agents_dir: Optional[Path] = None,
+        service_container: Optional[ServiceContainer] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ):
         """
-        Initialize framework loader.
-        
+        Initialize framework loader with modular components.
+
         Args:
             framework_path: Explicit path to framework (auto-detected if None)
             agents_dir: Custom agents directory (overrides framework agents)
+            service_container: Optional service container for dependency injection
+            config: Optional configuration dictionary for API validation and other settings
         """
         self.logger = get_logger("framework_loader")
-        self.framework_path = framework_path or self._detect_framework_path()
         self.agents_dir = agents_dir
         self.framework_version = None
         self.framework_last_modified = None
+        self.config = config or {}
+
+        # Validate API keys on startup (before any other initialization)
+        self._validate_api_keys()
+
+        # Initialize service container
+        self.container = service_container or get_global_container()
+        self._register_services()
+
+        # Resolve services from container
+        self._cache_manager = self.container.resolve(ICacheManager)
+        self._path_resolver = self.container.resolve(IPathResolver)
+        self._memory_manager = self.container.resolve(IMemoryManager)
+
+        # Initialize framework path
+        self.framework_path = (
+            framework_path or self._path_resolver.detect_framework_path()
+        )
+
+        # Initialize modular components
+        self._init_components()
+
+        # Keep cache TTL constants for backward compatibility
+        self._init_cache_ttl()
+
+        # Load framework content
         self.framework_content = self._load_framework_content()
-        
+
         # Initialize agent registry
         self.agent_registry = AgentRegistryAdapter(self.framework_path)
-        
-    def _detect_framework_path(self) -> Optional[Path]:
-        """Auto-detect claude-mpm framework."""
-        # First check if we're in claude-mpm project
-        current_file = Path(__file__)
-        if "claude-mpm" in str(current_file):
-            # We're running from claude-mpm, use its agents
-            for parent in current_file.parents:
-                if parent.name == "claude-mpm":
-                    if (parent / "src" / "claude_mpm" / "agents").exists():
-                        self.logger.info(f"Using claude-mpm at: {parent}")
-                        return parent
-                    break
-        
-        # Otherwise check common locations for claude-mpm
-        candidates = [
-            # Development location
-            Path.home() / "Projects" / "claude-mpm",
-            # Current directory
-            Path.cwd() / "claude-mpm",
-        ]
-        
-        for candidate in candidates:
-            if candidate and candidate.exists():
-                # Check for claude-mpm agents directory
-                if (candidate / "src" / "claude_mpm" / "agents").exists():
-                    self.logger.info(f"Found claude-mpm at: {candidate}")
-                    return candidate
-        
-        self.logger.warning("Framework not found, will use minimal instructions")
-        return None
-    
-    def _get_npm_global_path(self) -> Optional[Path]:
-        """Get npm global installation path."""
-        try:
-            import subprocess
-            result = subprocess.run(
-                ["npm", "root", "-g"],
-                capture_output=True,
-                text=True,
-                timeout=5
+
+        # Output style manager (deferred initialization)
+        self.output_style_manager = None
+
+    def _validate_api_keys(self) -> None:
+        """Validate API keys if enabled in config."""
+        if self.config.get("validate_api_keys", True):
+            try:
+                self.logger.info("Validating configured API keys...")
+                validate_api_keys(config=self.config, strict=True)
+                self.logger.info("✅ API key validation completed successfully")
+            except ValueError as e:
+                self.logger.error(f"❌ API key validation failed: {e}")
+                raise
+            except Exception as e:
+                self.logger.error(f"❌ Unexpected error during API validation: {e}")
+                raise
+
+    def _register_services(self) -> None:
+        """Register services in the container if not already registered."""
+        if not self.container.is_registered(ICacheManager):
+            self.container.register(ICacheManager, CacheManager, True)
+
+        if not self.container.is_registered(IPathResolver):
+            cache_manager = self.container.resolve(ICacheManager)
+            path_resolver = PathResolver(cache_manager=cache_manager)
+            self.container.register_instance(IPathResolver, path_resolver)
+
+        if not self.container.is_registered(IMemoryManager):
+            cache_manager = self.container.resolve(ICacheManager)
+            path_resolver = self.container.resolve(IPathResolver)
+            memory_manager = MemoryManager(
+                cache_manager=cache_manager, path_resolver=path_resolver
             )
-            if result.returncode == 0:
-                npm_root = Path(result.stdout.strip())
-                return npm_root / "@bobmatnyc" / "claude-multiagent-pm"
-        except:
-            pass
-        return None
-    
-    def _discover_framework_paths(self) -> tuple[Optional[Path], Optional[Path], Optional[Path]]:
-        """
-        Discover agent directories based on priority.
-        
-        Returns:
-            Tuple of (agents_dir, templates_dir, main_dir)
-        """
-        agents_dir = None
-        templates_dir = None
-        main_dir = None
-        
-        if self.agents_dir and self.agents_dir.exists():
-            agents_dir = self.agents_dir
-            self.logger.info(f"Using custom agents directory: {agents_dir}")
-        elif self.framework_path:
-            # Prioritize templates directory over main agents directory
-            templates_dir = self.framework_path / "src" / "claude_mpm" / "agents" / "templates"
-            main_dir = self.framework_path / "src" / "claude_mpm" / "agents"
-            
-            if templates_dir.exists() and any(templates_dir.glob("*.md")):
-                agents_dir = templates_dir
-                self.logger.info(f"Using agents from templates directory: {agents_dir}")
-            elif main_dir.exists() and any(main_dir.glob("*.md")):
-                agents_dir = main_dir
-                self.logger.info(f"Using agents from main directory: {agents_dir}")
-                
-        return agents_dir, templates_dir, main_dir
-    
-    def _try_load_file(self, file_path: Path, file_type: str) -> Optional[str]:
-        """
-        Try to load a file with error handling.
-        
-        Args:
-            file_path: Path to the file to load
-            file_type: Description of file type for logging
-            
-        Returns:
-            File content if successful, None otherwise
-        """
-        try:
-            content = file_path.read_text()
-            if hasattr(self.logger, 'level') and self.logger.level <= logging.INFO:
-                self.logger.info(f"Loaded {file_type} from: {file_path}")
-            
-            # Extract metadata if present
-            import re
-            version_match = re.search(r'<!-- FRAMEWORK_VERSION: (\d+) -->', content)
-            if version_match:
-                version = version_match.group(1)  # Keep as string to preserve leading zeros
-                self.logger.info(f"Framework version: {version}")
-                # Store framework version if this is the main INSTRUCTIONS.md
-                if 'INSTRUCTIONS.md' in str(file_path):
-                    self.framework_version = version
-                    
-            # Extract modification timestamp
-            timestamp_match = re.search(r'<!-- LAST_MODIFIED: ([^>]+) -->', content)
-            if timestamp_match:
-                timestamp = timestamp_match.group(1).strip()
-                self.logger.info(f"Last modified: {timestamp}")
-                # Store timestamp if this is the main INSTRUCTIONS.md
-                if 'INSTRUCTIONS.md' in str(file_path):
-                    self.framework_last_modified = timestamp
-            
-            return content
-        except Exception as e:
-            if hasattr(self.logger, 'level') and self.logger.level <= logging.ERROR:
-                self.logger.error(f"Failed to load {file_type}: {e}")
-            return None
-    
-    def _load_instructions_file(self, content: Dict[str, Any]) -> None:
-        """
-        Load INSTRUCTIONS.md or legacy CLAUDE.md from working directory.
-        
-        Args:
-            content: Dictionary to update with loaded instructions
-        """
-        working_instructions = Path.cwd() / "INSTRUCTIONS.md"
-        working_claude = Path.cwd() / "CLAUDE.md"  # Legacy support
-        
-        if working_instructions.exists():
-            loaded_content = self._try_load_file(working_instructions, "working directory INSTRUCTIONS.md")
-            if loaded_content:
-                content["working_claude_md"] = loaded_content
-        elif working_claude.exists():
-            # Legacy support for CLAUDE.md
-            loaded_content = self._try_load_file(working_claude, "working directory CLAUDE.md (legacy)")
-            if loaded_content:
-                content["working_claude_md"] = loaded_content
-    
-    def _load_single_agent(self, agent_file: Path) -> tuple[Optional[str], Optional[str]]:
-        """
-        Load a single agent file.
-        
-        Args:
-            agent_file: Path to the agent file
-            
-        Returns:
-            Tuple of (agent_name, agent_content) or (None, None) on failure
-        """
-        try:
-            agent_name = agent_file.stem
-            # Skip README files
-            if agent_name.upper() == "README":
-                return None, None
-            content = agent_file.read_text()
-            self.logger.debug(f"Loaded agent: {agent_name}")
-            return agent_name, content
-        except Exception as e:
-            self.logger.error(f"Failed to load agent {agent_file}: {e}")
-            return None, None
-    
-    def _load_base_agent_fallback(self, content: Dict[str, Any], main_dir: Optional[Path]) -> None:
-        """
-        Load base_agent.md from main directory as fallback.
-        
-        Args:
-            content: Dictionary to update with base agent
-            main_dir: Main agents directory path
-        """
-        if main_dir and main_dir.exists() and "base_agent" not in content["agents"]:
-            base_agent_file = main_dir / "base_agent.md"
-            if base_agent_file.exists():
-                agent_name, agent_content = self._load_single_agent(base_agent_file)
-                if agent_name and agent_content:
-                    content["agents"][agent_name] = agent_content
-    
-    def _load_agents_directory(self, content: Dict[str, Any], agents_dir: Optional[Path], 
-                               templates_dir: Optional[Path], main_dir: Optional[Path]) -> None:
-        """
-        Load agent definitions from the appropriate directory.
-        
-        Args:
-            content: Dictionary to update with loaded agents
-            agents_dir: Primary agents directory to load from
-            templates_dir: Templates directory path
-            main_dir: Main agents directory path
-        """
-        if not agents_dir or not agents_dir.exists():
-            return
-            
-        content["loaded"] = True
-        
-        # Load all agent files
-        for agent_file in agents_dir.glob("*.md"):
-            agent_name, agent_content = self._load_single_agent(agent_file)
-            if agent_name and agent_content:
-                content["agents"][agent_name] = agent_content
-        
-        # If we used templates dir, also check main dir for base_agent.md
-        if agents_dir == templates_dir:
-            self._load_base_agent_fallback(content, main_dir)
-    
+            self.container.register_instance(IMemoryManager, memory_manager)
+
+    def _init_components(self) -> None:
+        """Initialize modular components."""
+        # Loaders
+        self.file_loader = FileLoader()
+        self.packaged_loader = PackagedLoader()
+        self.instruction_loader = InstructionLoader(self.framework_path)
+        self.agent_loader = AgentLoader(self.framework_path)
+
+        # Formatters
+        self.content_formatter = ContentFormatter()
+        self.capability_generator = CapabilityGenerator()
+        self.context_generator = ContextGenerator()
+
+        # Processors
+        self.metadata_processor = MetadataProcessor()
+        self.template_processor = TemplateProcessor(self.framework_path)
+        self.memory_processor = MemoryProcessor()
+
+    def _init_cache_ttl(self) -> None:
+        """Initialize cache TTL constants for backward compatibility."""
+        if hasattr(self._cache_manager, "capabilities_ttl"):
+            self.CAPABILITIES_CACHE_TTL = self._cache_manager.capabilities_ttl
+            self.DEPLOYED_AGENTS_CACHE_TTL = self._cache_manager.deployed_agents_ttl
+            self.METADATA_CACHE_TTL = self._cache_manager.metadata_ttl
+            self.MEMORIES_CACHE_TTL = self._cache_manager.memories_ttl
+        else:
+            # Default TTL values
+            self.CAPABILITIES_CACHE_TTL = 60
+            self.DEPLOYED_AGENTS_CACHE_TTL = 30
+            self.METADATA_CACHE_TTL = 60
+            self.MEMORIES_CACHE_TTL = 60
+
+    # === Cache Management Methods (backward compatibility) ===
+
+    def clear_all_caches(self) -> None:
+        """Clear all caches to force reload on next access."""
+        self._cache_manager.clear_all()
+
+    def clear_agent_caches(self) -> None:
+        """Clear agent-related caches."""
+        self._cache_manager.clear_agent_caches()
+
+    def clear_memory_caches(self) -> None:
+        """Clear memory-related caches."""
+        self._cache_manager.clear_memory_caches()
+
+    # === Content Loading Methods ===
+
     def _load_framework_content(self) -> Dict[str, Any]:
-        """Load framework content."""
+        """Load framework content using modular components."""
         content = {
             "claude_md": "",
             "agents": {},
             "version": "unknown",
             "loaded": False,
             "working_claude_md": "",
-            "framework_instructions": ""
+            "framework_instructions": "",
+            "workflow_instructions": "",
+            "workflow_instructions_level": "",
+            "memory_instructions": "",
+            "memory_instructions_level": "",
+            "project_workflow": "",  # Deprecated
+            "project_memory": "",  # Deprecated
+            "actual_memories": "",
+            "agent_memories": {},
         }
-        
-        # Load instructions file from working directory
-        self._load_instructions_file(content)
-        
-        if not self.framework_path:
-            return content
-        
-        # Load framework's INSTRUCTIONS.md
-        framework_instructions_path = self.framework_path / "src" / "claude_mpm" / "agents" / "INSTRUCTIONS.md"
-        if framework_instructions_path.exists():
-            loaded_content = self._try_load_file(framework_instructions_path, "framework INSTRUCTIONS.md")
-            if loaded_content:
-                content["framework_instructions"] = loaded_content
-                content["loaded"] = True
-                # Add framework version to content
-                if self.framework_version:
-                    content["instructions_version"] = self.framework_version
-                    content["version"] = self.framework_version  # Update main version key
-                # Add modification timestamp to content
-                if self.framework_last_modified:
-                    content["instructions_last_modified"] = self.framework_last_modified
-        
-        # Discover agent directories
-        agents_dir, templates_dir, main_dir = self._discover_framework_paths()
-        
-        # Load agents from discovered directory
-        self._load_agents_directory(content, agents_dir, templates_dir, main_dir)
-        
+
+        # Load all instructions
+        self.instruction_loader.load_all_instructions(content)
+
+        # Transfer metadata from loaders
+        if self.file_loader.framework_version:
+            self.framework_version = self.file_loader.framework_version
+            content["version"] = self.framework_version
+        if self.file_loader.framework_last_modified:
+            self.framework_last_modified = self.file_loader.framework_last_modified
+
+        # Load memories
+        self._load_actual_memories(content)
+
+        # Discover and load agents
+        agents_dir, templates_dir, main_dir = self._path_resolver.discover_agent_paths(
+            agents_dir=self.agents_dir, framework_path=self.framework_path
+        )
+        agents = self.agent_loader.load_agents_directory(
+            agents_dir, templates_dir, main_dir
+        )
+        if agents:
+            content["agents"] = agents
+            content["loaded"] = True
+
         return content
-    
+
+    def _load_actual_memories(self, content: Dict[str, Any]) -> None:
+        """Load actual memories using the MemoryManager service."""
+        memories = self._memory_manager.load_memories()
+
+        # Only load PM memories (PM.md)
+        # Agent memories are loaded at deployment time in agent_template_builder.py
+        if "actual_memories" in memories:
+            content["actual_memories"] = memories["actual_memories"]
+        # NOTE: agent_memories are no longer loaded for PM instructions
+        # They are injected per-agent at deployment time
+
+    # === Agent Discovery Methods ===
+
+    def _get_deployed_agents(self) -> Set[str]:
+        """Get deployed agents with caching."""
+        cached = self._cache_manager.get_deployed_agents()
+        if cached is not None:
+            return cached
+
+        deployed = self.agent_loader.get_deployed_agents()
+        self._cache_manager.set_deployed_agents(deployed)
+        return deployed
+
+    def _discover_local_json_templates(self) -> Dict[str, Dict[str, Any]]:
+        """Discover local JSON agent templates."""
+        return self.agent_loader.discover_local_json_templates()
+
+    def _parse_agent_metadata(self, agent_file: Path) -> Optional[Dict[str, Any]]:
+        """Parse agent metadata with caching."""
+        cache_key = str(agent_file)
+        file_mtime = agent_file.stat().st_mtime
+
+        # Try cache first
+        cached_result = self._cache_manager.get_agent_metadata(cache_key)
+        if cached_result is not None:
+            cached_data, cached_mtime = cached_result
+            if cached_mtime == file_mtime:
+                self.logger.debug(f"Using cached metadata for {agent_file.name}")
+                return cached_data
+
+        # Cache miss - parse the file
+        agent_data = self.metadata_processor.parse_agent_metadata(agent_file)
+
+        # Add routing information if not present
+        if agent_data and "routing" not in agent_data:
+            template_data = self.template_processor.load_template(agent_file.stem)
+            if template_data:
+                routing = self.template_processor.extract_routing(template_data)
+                if routing:
+                    agent_data["routing"] = routing
+                memory_routing = self.template_processor.extract_memory_routing(
+                    template_data
+                )
+                if memory_routing:
+                    agent_data["memory_routing"] = memory_routing
+
+        # Cache the result
+        if agent_data:
+            self._cache_manager.set_agent_metadata(cache_key, agent_data, file_mtime)
+
+        return agent_data
+
+    # === Framework Instructions Generation ===
+
     def get_framework_instructions(self) -> str:
         """
         Get formatted framework instructions for injection.
-        
+
         Returns:
             Complete framework instructions ready for injection
         """
-        if self.framework_content["loaded"] or self.framework_content["working_claude_md"]:
-            # Build framework from components
+        # Log the system prompt if needed
+        self._log_system_prompt()
+
+        # Generate the instructions
+        if self.framework_content["loaded"]:
             return self._format_full_framework()
-        else:
-            # Use minimal fallback
-            return self._format_minimal_framework()
-    
+        return self._format_minimal_framework()
+
     def _format_full_framework(self) -> str:
-        """Format full framework instructions."""
-        from datetime import datetime
-        
-        # If we have the full framework INSTRUCTIONS.md, use it
-        if self.framework_content.get("framework_instructions"):
-            instructions = self.framework_content["framework_instructions"]
-            
-            # Add working directory instructions if they exist
-            if self.framework_content["working_claude_md"]:
-                instructions += f"\n\n## Working Directory Instructions\n{self.framework_content['working_claude_md']}\n"
-            
-            return instructions
-        
-        # Otherwise fall back to generating framework
-        instructions = f"""
-<!-- Framework injected by Claude MPM -->
-<!-- Version: {self.framework_content['version']} -->
-<!-- Timestamp: {datetime.now().isoformat()} -->
-
-# Claude MPM Framework Instructions
-
-You are operating within the Claude Multi-Agent Project Manager (MPM) framework.
-
-## Core Role
-You are a multi-agent orchestrator. Your primary responsibilities are:
-- Delegate all implementation work to specialized agents via Task Tool
-- Coordinate multi-agent workflows and cross-agent collaboration
-- Extract and track TODO/BUG/FEATURE items for ticket creation
-- Maintain project visibility and strategic oversight
-- NEVER perform direct implementation work yourself
-
-"""
-        
-        # Add working directory INSTRUCTIONS.md (or CLAUDE.md) if exists
-        if self.framework_content["working_claude_md"]:
-            instructions += f"""
-## Working Directory Instructions
-{self.framework_content["working_claude_md"]}
-
-"""
-        
-        # Add agent definitions
-        if self.framework_content["agents"]:
-            instructions += "## Available Agents\n\n"
-            instructions += "You have the following specialized agents available for delegation:\n\n"
-            
-            # List agents with brief descriptions
-            agent_list = []
-            for agent_name in sorted(self.framework_content["agents"].keys()):
-                clean_name = agent_name.replace('-', ' ').replace('_', ' ').title()
-                if 'engineer' in agent_name.lower():
-                    agent_list.append(f"- **Engineer Agent**: Code implementation and development")
-                elif 'qa' in agent_name.lower():
-                    agent_list.append(f"- **QA Agent**: Testing and quality assurance")
-                elif 'documentation' in agent_name.lower():
-                    agent_list.append(f"- **Documentation Agent**: Documentation creation and maintenance")
-                elif 'research' in agent_name.lower():
-                    agent_list.append(f"- **Research Agent**: Investigation and analysis")
-                elif 'security' in agent_name.lower():
-                    agent_list.append(f"- **Security Agent**: Security analysis and protection")
-                elif 'version' in agent_name.lower():
-                    agent_list.append(f"- **Version Control Agent**: Git operations and version management")
-                elif 'ops' in agent_name.lower():
-                    agent_list.append(f"- **Ops Agent**: Deployment and operations")
-                elif 'data' in agent_name.lower():
-                    agent_list.append(f"- **Data Engineer Agent**: Data management and AI API integration")
-                else:
-                    agent_list.append(f"- **{clean_name}**: Available for specialized tasks")
-            
-            instructions += "\n".join(agent_list) + "\n\n"
-            
-            # Add full agent details
-            instructions += "### Agent Details\n\n"
-            for agent_name, agent_content in sorted(self.framework_content["agents"].items()):
-                instructions += f"#### {agent_name.replace('-', ' ').title()}\n"
-                instructions += agent_content + "\n\n"
-        
-        # Add orchestration principles
-        instructions += """
-## Orchestration Principles
-1. **Always Delegate**: Never perform direct work - use Task Tool for all implementation
-2. **Comprehensive Context**: Provide rich, filtered context to each agent
-3. **Track Everything**: Extract all TODO/BUG/FEATURE items systematically
-4. **Cross-Agent Coordination**: Orchestrate workflows spanning multiple agents
-5. **Results Integration**: Actively receive and integrate agent results
-
-## Task Tool Format
-```
-**[Agent Name]**: [Clear task description with deliverables]
-
-TEMPORAL CONTEXT: Today is [date]. Apply date awareness to [specific considerations].
-
-**Task**: [Detailed task breakdown]
-1. [Specific action item 1]
-2. [Specific action item 2]
-3. [Specific action item 3]
-
-**Context**: [Comprehensive filtered context for this agent]
-**Authority**: [Agent's decision-making scope]
-**Expected Results**: [Specific deliverables needed]
-**Integration**: [How results integrate with other work]
-```
-
-## Ticket Extraction Patterns
-Extract tickets from these patterns:
-- TODO: [description] → TODO ticket
-- BUG: [description] → BUG ticket
-- FEATURE: [description] → FEATURE ticket
-- ISSUE: [description] → ISSUE ticket
-- FIXME: [description] → BUG ticket
-
----
-"""
-        
-        return instructions
-    
+        """Format full framework instructions using modular components."""
+        # Initialize output style manager on first use
+        if self.output_style_manager is None:
+            self._initialize_output_style()
+
+        # Check if we need to inject output style
+        inject_output_style = False
+        output_style_content = None
+        if self.output_style_manager:
+            inject_output_style = self.output_style_manager.should_inject_content()
+            if inject_output_style:
+                output_style_content = self.output_style_manager.get_injectable_content(
+                    framework_loader=self
+                )
+                self.logger.info("Injecting output style content for Claude < 1.0.83")
+
+        # Generate dynamic sections
+        capabilities_section = self._generate_agent_capabilities_section()
+        context_section = self.context_generator.generate_temporal_user_context()
+
+        # Format the complete framework
+        return self.content_formatter.format_full_framework(
+            self.framework_content,
+            capabilities_section,
+            context_section,
+            inject_output_style,
+            output_style_content,
+        )
+
     def _format_minimal_framework(self) -> str:
-        """Format minimal framework instructions when full framework not available."""
-        return """
-# Claude PM Framework Instructions
-
-You are operating within a Claude PM Framework deployment.
-
-## Role
-You are a multi-agent orchestrator. Your primary responsibilities:
-- Delegate tasks to specialized agents via Task Tool
-- Coordinate multi-agent workflows
-- Extract TODO/BUG/FEATURE items for ticket creation
-- NEVER perform direct implementation work
-
-## Core Agents
-- Documentation Agent - Documentation tasks
-- Engineer Agent - Code implementation  
-- QA Agent - Testing and validation
-- Research Agent - Investigation and analysis
-- Version Control Agent - Git operations
-
-## Important Rules
-1. Always delegate work via Task Tool
-2. Provide comprehensive context to agents
-3. Track all TODO/BUG/FEATURE items
-4. Maintain project visibility
-
----
-"""
-    
-    def get_agent_list(self) -> list:
+        """Format minimal framework instructions."""
+        return self.content_formatter.format_minimal_framework(self.framework_content)
+
+    def _generate_agent_capabilities_section(self) -> str:
+        """Generate agent capabilities section with caching."""
+        # Try cache first
+        cached_capabilities = self._cache_manager.get_capabilities()
+        if cached_capabilities is not None:
+            return cached_capabilities
+
+        self.logger.debug("Generating agent capabilities (cache miss)")
+
+        try:
+            # Discover local JSON templates
+            local_agents = self._discover_local_json_templates()
+
+            # Get deployed agents from .claude/agents/
+            deployed_agents = []
+            agents_dirs = [
+                Path.cwd() / ".claude" / "agents",
+                Path.home() / ".claude" / "agents",
+            ]
+
+            for agents_dir in agents_dirs:
+                if agents_dir.exists():
+                    for agent_file in agents_dir.glob("*.md"):
+                        if not agent_file.name.startswith("."):
+                            agent_data = self._parse_agent_metadata(agent_file)
+                            if agent_data:
+                                deployed_agents.append(agent_data)
+
+            # Generate capabilities section
+            section = self.capability_generator.generate_capabilities_section(
+                deployed_agents, local_agents
+            )
+
+            # Cache the result
+            self._cache_manager.set_capabilities(section)
+            self.logger.debug(f"Cached agent capabilities ({len(section)} chars)")
+
+            return section
+
+        except Exception as e:
+            self.logger.warning(f"Could not generate agent capabilities: {e}")
+            fallback = self.content_formatter.get_fallback_capabilities()
+            self._cache_manager.set_capabilities(fallback)
+            return fallback
+
+    # === Output Style Management ===
+
+    def _initialize_output_style(self) -> None:
+        """Initialize output style management."""
+        try:
+            from claude_mpm.core.output_style_manager import OutputStyleManager
+
+            self.output_style_manager = OutputStyleManager()
+            self._log_output_style_status()
+
+            # Extract and save output style content
+            output_style_content = (
+                self.output_style_manager.extract_output_style_content(
+                    framework_loader=self
+                )
+            )
+            self.output_style_manager.save_output_style(output_style_content)
+
+            # Deploy to Claude Code if supported
+            deployed = self.output_style_manager.deploy_output_style(
+                output_style_content
+            )
+
+            if deployed:
+                self.logger.info("✅ Output style deployed to Claude Code >= 1.0.83")
+            else:
+                self.logger.info("📝 Output style will be injected into instructions")
+
+        except Exception as e:
+            self.logger.warning(f"❌ Failed to initialize output style manager: {e}")
+
+    def _log_output_style_status(self) -> None:
+        """Log output style status information."""
+        if not self.output_style_manager:
+            return
+
+        claude_version = self.output_style_manager.claude_version
+        if claude_version:
+            self.logger.info(f"Claude Code version detected: {claude_version}")
+
+            if self.output_style_manager.supports_output_styles():
+                self.logger.info("✅ Claude Code supports output styles (>= 1.0.83)")
+                output_style_path = self.output_style_manager.output_style_path
+                if output_style_path.exists():
+                    self.logger.info(
+                        f"📁 Output style file exists: {output_style_path}"
+                    )
+                else:
+                    self.logger.info(
+                        f"📝 Output style will be created at: {output_style_path}"
+                    )
+            else:
+                self.logger.info(
+                    f"⚠️ Claude Code {claude_version} does not support output styles"
+                )
+                self.logger.info(
+                    "📝 Output style will be injected into framework instructions"
+                )
+        else:
+            self.logger.info("⚠️ Claude Code not detected or version unknown")
+            self.logger.info("📝 Output style will be injected as fallback")
+
+    # === Logging Methods ===
+
+    def _log_system_prompt(self) -> None:
+        """Log the system prompt if LogManager is available."""
+        try:
+            from .log_manager import get_log_manager
+
+            log_manager = get_log_manager()
+        except ImportError:
+            return
+
+        try:
+            # Get or create event loop
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+
+            # Prepare metadata
+            metadata = {
+                "framework_version": self.framework_version,
+                "framework_loaded": self.framework_content.get("loaded", False),
+                "session_id": os.environ.get("CLAUDE_SESSION_ID", "unknown"),
+            }
+
+            # Log the prompt asynchronously
+            instructions = (
+                self._format_full_framework()
+                if self.framework_content["loaded"]
+                else self._format_minimal_framework()
+            )
+            metadata["instructions_length"] = len(instructions)
+
+            if loop.is_running():
+                _task = asyncio.create_task(
+                    log_manager.log_prompt("system_prompt", instructions, metadata)
+                )  # Fire-and-forget logging
+            else:
+                loop.run_until_complete(
+                    log_manager.log_prompt("system_prompt", instructions, metadata)
+                )
+
+            self.logger.debug("System prompt logged to prompts directory")
+        except Exception as e:
+            self.logger.debug(f"Could not log system prompt: {e}")
+
+    # === Agent Registry Methods (backward compatibility) ===
+
+    def get_agent_list(self) -> List[str]:
         """Get list of available agents."""
-        # First try agent registry
         if self.agent_registry:
             agents = self.agent_registry.list_agents()
             if agents:
                 return list(agents.keys())
-        
-        # Fallback to loaded content
         return list(self.framework_content["agents"].keys())
-    
+
     def get_agent_definition(self, agent_name: str) -> Optional[str]:
         """Get specific agent definition."""
-        # First try agent registry
         if self.agent_registry:
             definition = self.agent_registry.get_agent_definition(agent_name)
             if definition:
                 return definition
-        
-        # Fallback to loaded content
         return self.framework_content["agents"].get(agent_name)
-    
-    def get_agent_hierarchy(self) -> Dict[str, list]:
+
+    def get_agent_hierarchy(self) -> Dict[str, List]:
         """Get agent hierarchy from registry."""
         if self.agent_registry:
             return self.agent_registry.get_agent_hierarchy()
-        return {'project': [], 'user': [], 'system': []}
+        return {"project": [], "user": [], "system": []}