claude-mpm 4.20.3__py3-none-any.whl → 5.1.8__py3-none-any.whl

claude_mpm/core/claude_runner.py

@@ -6,15 +6,9 @@ from typing import Optional
 
 # 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,
-)
+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
 
@@ -42,8 +36,19 @@ class ClaudeRunner:
         launch_method: str = "exec",  # "exec" or "subprocess"
         enable_websocket: bool = False,
         websocket_port: int = 8765,
+        use_native_agents: bool = False,  # Use --agents flag instead of file deployment
     ):
-        """Initialize the Claude runner."""
+        """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
@@ -75,6 +80,7 @@ class ClaudeRunner:
             launch_method=launch_method,
             enable_websocket=enable_websocket,
             websocket_port=websocket_port,
+            use_native_agents=use_native_agents,
         )
 
         # Set configuration attributes
@@ -84,6 +90,7 @@ class ClaudeRunner:
         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
@@ -795,31 +802,8 @@ Use these agents to delegate specialized work via the Task tool.
             raise RuntimeError("Subprocess launcher service not available")
 
 
-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"
-
-Both formats work correctly. When you see capitalized names (matching TodoWrite prefixes),
-automatically normalize them to lowercase-hyphenated format for the Task tool.
-
-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

claude_mpm/core/config.py

@@ -583,6 +583,30 @@ class Config:
                 "auto_save": True,  # Enable automatic session saving
                 "save_interval": 300,  # Auto-save interval in seconds (5 minutes)
             },
+            # Update checking configuration
+            "updates": {
+                "check_enabled": True,  # Enable automatic update checks
+                "check_frequency": "daily",  # Options: "always", "daily", "weekly", "never"
+                "check_claude_code": True,  # Check Claude Code version compatibility
+                "auto_upgrade": False,  # Automatically upgrade without prompting (use with caution)
+                "cache_ttl": 86400,  # Cache update check results (24 hours)
+            },
+            # Agent synchronization configuration
+            "agent_sync": {
+                "enabled": True,  # Enable automatic agent sync on startup
+                "sources": [
+                    {
+                        "id": "github-remote",
+                        "url": "https://raw.githubusercontent.com/bobmatnyc/claude-mpm-agents/main/agents",
+                        "priority": 100,
+                        "enabled": True,
+                    }
+                ],
+                "sync_interval": "startup",  # Options: "startup", "hourly", "daily", "manual"
+                "cache_dir": str(
+                    Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+                ),
+            },
         }
 
         # Apply defaults for missing keys

claude_mpm/core/constants.py

@@ -215,7 +215,7 @@ class Defaults:
     DEFAULT_TEMPERATURE = 0.5
 
     # Logging defaults
-    DEFAULT_LOG_LEVEL = "INFO"
+    DEFAULT_LOG_LEVEL = "OFF"
     DEFAULT_LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 
     # Session defaults

claude_mpm/core/framework/__init__.py

@@ -4,22 +4,9 @@ This module provides the modular framework loading system with specialized compo
 for handling different aspects of framework initialization and management.
 """
 
-from .formatters import (
-    CapabilityGenerator,
-    ContentFormatter,
-    ContextGenerator,
-)
-from .loaders import (
-    AgentLoader,
-    FileLoader,
-    InstructionLoader,
-    PackagedLoader,
-)
-from .processors import (
-    MemoryProcessor,
-    MetadataProcessor,
-    TemplateProcessor,
-)
+from .formatters import CapabilityGenerator, ContentFormatter, ContextGenerator
+from .loaders import AgentLoader, FileLoader, InstructionLoader, PackagedLoader
+from .processors import MemoryProcessor, MetadataProcessor, TemplateProcessor
 
 __all__ = [
     "AgentLoader",

claude_mpm/core/framework/loaders/file_loader.py

@@ -66,6 +66,53 @@ class FileLoader:
             if "INSTRUCTIONS.md" in str(file_path):
                 self.framework_last_modified = timestamp
 
+    def _load_tier_file(
+        self,
+        filename: str,
+        current_dir: Path,
+        framework_path: Optional[Path] = None,
+        include_system: bool = False,
+    ) -> tuple[Optional[str], Optional[str]]:
+        """Load file with tier precedence: project → user → system.
+
+        Args:
+            filename: Name of file to load (e.g., "INSTRUCTIONS.md")
+            current_dir: Current working directory for project-level
+            framework_path: Path to framework installation for system-level
+            include_system: Whether to check system-level path
+
+        Returns:
+            Tuple of (content, level) where level is 'project', 'user', 'system', or None
+        """
+        # Check project-level (highest priority)
+        project_path = current_dir / ".claude-mpm" / filename
+        if project_path.exists():
+            loaded_content = self.try_load_file(
+                project_path, f"project-specific {filename}"
+            )
+            if loaded_content:
+                self.logger.info(f"Using project-specific {filename} from .claude-mpm/")
+                return loaded_content, "project"
+
+        # Check user-level (medium priority)
+        user_path = Path.home() / ".claude-mpm" / filename
+        if user_path.exists():
+            loaded_content = self.try_load_file(user_path, f"user-specific {filename}")
+            if loaded_content:
+                self.logger.info(f"Using user-specific {filename} from ~/.claude-mpm/")
+                return loaded_content, "user"
+
+        # Check system-level (lowest priority)
+        if include_system and framework_path and framework_path != Path("__PACKAGED__"):
+            system_path = framework_path / "src" / "claude_mpm" / "agents" / filename
+            if system_path.exists():
+                loaded_content = self.try_load_file(system_path, f"system {filename}")
+                if loaded_content:
+                    self.logger.info(f"Using system {filename}")
+                    return loaded_content, "system"
+
+        return None, None
+
     def load_instructions_file(
         self, current_dir: Path
     ) -> tuple[Optional[str], Optional[str]]:
@@ -82,31 +129,7 @@ class FileLoader:
         Returns:
             Tuple of (content, level) where level is 'project', 'user', or None
         """
-        # Check for project-specific INSTRUCTIONS.md first
-        project_instructions_path = current_dir / ".claude-mpm" / "INSTRUCTIONS.md"
-        if project_instructions_path.exists():
-            loaded_content = self.try_load_file(
-                project_instructions_path, "project-specific INSTRUCTIONS.md"
-            )
-            if loaded_content:
-                self.logger.info(
-                    "Using project-specific PM instructions from .claude-mpm/INSTRUCTIONS.md"
-                )
-                return loaded_content, "project"
-
-        # Check for user-specific INSTRUCTIONS.md
-        user_instructions_path = Path.home() / ".claude-mpm" / "INSTRUCTIONS.md"
-        if user_instructions_path.exists():
-            loaded_content = self.try_load_file(
-                user_instructions_path, "user-specific INSTRUCTIONS.md"
-            )
-            if loaded_content:
-                self.logger.info(
-                    "Using user-specific PM instructions from ~/.claude-mpm/INSTRUCTIONS.md"
-                )
-                return loaded_content, "user"
-
-        return None, None
+        return self._load_tier_file("INSTRUCTIONS.md", current_dir)
 
     def load_workflow_file(
         self, current_dir: Path, framework_path: Path
@@ -126,44 +149,9 @@ class FileLoader:
         Returns:
             Tuple of (content, level) where level is 'project', 'user', 'system', or None
         """
-        # Check for project-specific WORKFLOW.md first (highest priority)
-        project_workflow_path = current_dir / ".claude-mpm" / "WORKFLOW.md"
-        if project_workflow_path.exists():
-            loaded_content = self.try_load_file(
-                project_workflow_path, "project-specific WORKFLOW.md"
-            )
-            if loaded_content:
-                self.logger.info(
-                    "Using project-specific workflow instructions from .claude-mpm/WORKFLOW.md"
-                )
-                return loaded_content, "project"
-
-        # Check for user-specific WORKFLOW.md (medium priority)
-        user_workflow_path = Path.home() / ".claude-mpm" / "WORKFLOW.md"
-        if user_workflow_path.exists():
-            loaded_content = self.try_load_file(
-                user_workflow_path, "user-specific WORKFLOW.md"
-            )
-            if loaded_content:
-                self.logger.info(
-                    "Using user-specific workflow instructions from ~/.claude-mpm/WORKFLOW.md"
-                )
-                return loaded_content, "user"
-
-        # Fall back to system workflow (lowest priority)
-        if framework_path and framework_path != Path("__PACKAGED__"):
-            system_workflow_path = (
-                framework_path / "src" / "claude_mpm" / "agents" / "WORKFLOW.md"
-            )
-            if system_workflow_path.exists():
-                loaded_content = self.try_load_file(
-                    system_workflow_path, "system WORKFLOW.md"
-                )
-                if loaded_content:
-                    self.logger.info("Using system workflow instructions")
-                    return loaded_content, "system"
-
-        return None, None
+        return self._load_tier_file(
+            "WORKFLOW.md", current_dir, framework_path, include_system=True
+        )
 
     def load_memory_file(
         self, current_dir: Path, framework_path: Path
@@ -183,41 +171,6 @@ class FileLoader:
         Returns:
             Tuple of (content, level) where level is 'project', 'user', 'system', or None
         """
-        # Check for project-specific MEMORY.md first (highest priority)
-        project_memory_path = current_dir / ".claude-mpm" / "MEMORY.md"
-        if project_memory_path.exists():
-            loaded_content = self.try_load_file(
-                project_memory_path, "project-specific MEMORY.md"
-            )
-            if loaded_content:
-                self.logger.info(
-                    "Using project-specific memory instructions from .claude-mpm/MEMORY.md"
-                )
-                return loaded_content, "project"
-
-        # Check for user-specific MEMORY.md (medium priority)
-        user_memory_path = Path.home() / ".claude-mpm" / "MEMORY.md"
-        if user_memory_path.exists():
-            loaded_content = self.try_load_file(
-                user_memory_path, "user-specific MEMORY.md"
-            )
-            if loaded_content:
-                self.logger.info(
-                    "Using user-specific memory instructions from ~/.claude-mpm/MEMORY.md"
-                )
-                return loaded_content, "user"
-
-        # Fall back to system memory instructions (lowest priority)
-        if framework_path and framework_path != Path("__PACKAGED__"):
-            system_memory_path = (
-                framework_path / "src" / "claude_mpm" / "agents" / "MEMORY.md"
-            )
-            if system_memory_path.exists():
-                loaded_content = self.try_load_file(
-                    system_memory_path, "system MEMORY.md"
-                )
-                if loaded_content:
-                    self.logger.info("Using system memory instructions")
-                    return loaded_content, "system"
-
-        return None, None
+        return self._load_tier_file(
+            "MEMORY.md", current_dir, framework_path, include_system=True
+        )

claude_mpm/core/framework/loaders/instruction_loader.py

@@ -91,10 +91,28 @@ class InstructionLoader:
     def _load_filesystem_framework_instructions(self, content: Dict[str, Any]) -> None:
         """Load framework instructions from filesystem.
 
+        Priority order:
+        1. Deployed compiled file: .claude-mpm/PM_INSTRUCTIONS_DEPLOYED.md (HIGHEST PRIORITY)
+        2. Source file (development): src/claude_mpm/agents/PM_INSTRUCTIONS.md
+        3. Legacy file (backward compat): src/claude_mpm/agents/INSTRUCTIONS.md
+
         Args:
             content: Dictionary to update with framework instructions
         """
-        # Try new consolidated PM_INSTRUCTIONS.md first, fall back to INSTRUCTIONS.md
+        # PRIORITY 1: Check for compiled/deployed version in .claude-mpm/
+        # This is the merged PM_INSTRUCTIONS.md + WORKFLOW.md + MEMORY.md
+        deployed_path = self.current_dir / ".claude-mpm" / "PM_INSTRUCTIONS_DEPLOYED.md"
+        if deployed_path.exists():
+            loaded_content = self.file_loader.try_load_file(
+                deployed_path, "deployed PM_INSTRUCTIONS_DEPLOYED.md"
+            )
+            if loaded_content:
+                content["framework_instructions"] = loaded_content
+                content["loaded"] = True
+                self.logger.info("Loaded PM_INSTRUCTIONS_DEPLOYED.md from .claude-mpm/")
+                return  # Stop here - deployed version takes precedence
+
+        # PRIORITY 2: Development mode - load from source PM_INSTRUCTIONS.md
         pm_instructions_path = (
             self.framework_path / "src" / "claude_mpm" / "agents" / "PM_INSTRUCTIONS.md"
         )
@@ -102,16 +120,18 @@ class InstructionLoader:
             self.framework_path / "src" / "claude_mpm" / "agents" / "INSTRUCTIONS.md"
         )
 
-        # Try loading new consolidated file first
+        # Try loading new consolidated file
         if pm_instructions_path.exists():
             loaded_content = self.file_loader.try_load_file(
-                pm_instructions_path, "consolidated PM_INSTRUCTIONS.md"
+                pm_instructions_path, "source PM_INSTRUCTIONS.md (development mode)"
             )
             if loaded_content:
                 content["framework_instructions"] = loaded_content
                 content["loaded"] = True
-                self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md")
-        # Fall back to legacy file for backward compatibility
+                self.logger.warning(
+                    "Using source PM_INSTRUCTIONS.md - deployed version not found"
+                )
+        # PRIORITY 3: Fall back to legacy file for backward compatibility
         elif framework_instructions_path.exists():
             loaded_content = self.file_loader.try_load_file(
                 framework_instructions_path, "framework INSTRUCTIONS.md (legacy)"

claude_mpm/core/framework/processors/metadata_processor.py

@@ -127,7 +127,7 @@ class MetadataProcessor:
             True if cache is valid, False otherwise
         """
         try:
-            data, cache_time = cached_data
+            _data, cache_time = cached_data
             current_time = time.time()
 
             # Check TTL