claude-mpm 5.0.9__py3-none-any.whl → 5.4.41__py3-none-any.whl

claude_mpm/commands/mpm-version.md

@@ -4,119 +4,17 @@ command: version
 aliases: [mpm-version]
 migration_target: /mpm/system:version
 category: system
-deprecated_aliases: []
-description: Show comprehensive version information for Claude MPM
+description: Show version information
 ---
-# Display Claude MPM Version Information
+# /mpm-version
 
-Show comprehensive version information for Claude MPM project, agents, and skills.
+Display version information for MPM, agents, and skills.
 
 ## Usage
-
 ```
 /mpm-version
 ```
 
-## Description
-
-Display version information including:
-- Project version and build number
-- All deployed agents with their versions (grouped by tier: system/user/project)
-- All available skills with their versions (grouped by source: bundled/user/project)
-- Summary statistics
-
-## Implementation
-
-When you run `/mpm-version`, the PM will:
-
-1. **Collect Version Information**
-   - Use VersionService to gather all version data
-   - Project version from pyproject.toml
-   - Build number from BUILD_NUMBER file
-   - Agent versions from AgentRegistry
-   - Skills versions from SkillRegistry
-
-2. **Format Output**
-   - Hierarchical display: Project → Agents → Skills
-   - Grouped by tier/source for clarity
-   - Sorted alphabetically within groups
-   - Summary statistics at the end
-
-3. **Display Results**
-   - Well-formatted tree structure
-   - Easy to scan and read
-   - Includes totals and counts
-
-## Example Output
-
-```
-Claude MPM Version Information
-==============================
-
-Project Version: 4.16.3
-Build: 481
-
-Agents (35 total)
------------------
-
-System Agents (30):
-  ├─ agent-manager (1.0.0)
-  ├─ engineer (3.9.1)
-  ├─ research-agent (4.5.1)
-  ├─ documentation (2.1.0)
-  ├─ qa (2.0.3)
-  └─ ... (25 more)
-
-User Agents (3):
-  ├─ custom-agent (1.0.0)
-  ├─ testing-agent (0.5.0)
-  └─ prototype-agent (0.1.0)
-
-Project Agents (2):
-  ├─ project-specific (2.0.0)
-  └─ domain-expert (1.1.0)
-
-Skills (20 total)
------------------
-
-Bundled Skills (20):
-  ├─ test-driven-development (0.1.0)
-  ├─ systematic-debugging (0.1.0)
-  ├─ async-testing (0.1.0)
-  ├─ performance-profiling (0.1.0)
-  ├─ security-scanning (0.1.0)
-  └─ ... (15 more)
-
-User Skills (0):
-  (none)
-
-Project Skills (0):
-  (none)
-
-Summary
--------
-• Project: v4.16.3 (build 481)
-• Agents: 35 total (30 system, 3 user, 2 project)
-• Skills: 20 total (20 bundled, 0 user, 0 project)
-```
-
-## PM Implementation Instructions
-
-To execute this command, PM should:
-
-1. Import and use VersionService:
-   ```python
-   from claude_mpm.services.version_service import VersionService
-
-   service = VersionService()
-   summary = service.get_version_summary()
-   ```
-
-2. Format output following the example structure above
-3. Handle missing data gracefully (show "unknown" for missing versions)
-4. Include all tiers/sources even if counts are zero
-
-## Related Commands
+Shows project version, build number, all agents (by tier), all skills (by source).
 
-- `/mpm-help` - Show all available MPM commands
-- `/mpm-status` - Show system status information
+See docs/commands/version.md for details.

claude_mpm/config/agent_sources.py

@@ -316,6 +316,33 @@ class AgentSourceConfiguration:
 
         return errors
 
+    def list_sources(self) -> list[dict]:
+        """Return list of source configurations as dictionaries.
+
+        This method converts GitRepository objects to dictionaries for CLI
+        and API compatibility. Called by GitSourceManager and CLI commands.
+
+        Returns:
+            List of dicts with keys: identifier, url, subdirectory, enabled, priority
+
+        Example:
+            >>> config = AgentSourceConfiguration()
+            >>> sources = config.list_sources()
+            >>> for source in sources:
+            ...     print(f"{source['identifier']} (priority: {source['priority']})")
+        """
+        repos = self.get_enabled_repositories()
+        return [
+            {
+                "identifier": repo.identifier,
+                "url": repo.url,
+                "subdirectory": repo.subdirectory,
+                "enabled": repo.enabled,
+                "priority": repo.priority,
+            }
+            for repo in repos
+        ]
+
     def __repr__(self) -> str:
         """Return string representation of configuration."""
         return (

claude_mpm/core/config.py

@@ -563,7 +563,7 @@ class Config:
             # Instruction reinforcement system configuration
             "instruction_reinforcement": {
                 "enabled": True,
-                "test_mode": True,
+                "test_mode": False,
                 "injection_interval": 5,
                 "test_messages": [
                     "[TEST-REMINDER] This is an injected instruction reminder",
@@ -603,9 +603,7 @@ class Config:
                     }
                 ],
                 "sync_interval": "startup",  # Options: "startup", "hourly", "daily", "manual"
-                "cache_dir": str(
-                    Path.home() / ".claude-mpm" / "cache" / "remote-agents"
-                ),
+                "cache_dir": str(Path.home() / ".claude-mpm" / "cache" / "agents"),
             },
         }
 

claude_mpm/core/framework/formatters/content_formatter.py

@@ -100,19 +100,9 @@ class ContentFormatter:
                 instructions += framework_content["actual_memories"]
                 instructions += "\n"
 
-            # Add agent memories if available
-            if framework_content.get("agent_memories"):
-                agent_memories = framework_content["agent_memories"]
-                if agent_memories:
-                    instructions += "\n\n## Agent Memories\n\n"
-                    instructions += "**The following are accumulated memories from specialized agents:**\n\n"
-
-                    for agent_name in sorted(agent_memories.keys()):
-                        memory_content = agent_memories[agent_name]
-                        if memory_content:
-                            instructions += f"### {agent_name.replace('_', ' ').title()} Agent Memory\n\n"
-                            instructions += memory_content
-                            instructions += "\n\n"
+            # NOTE: Agent memories are now injected at agent deployment time
+            # in agent_template_builder.py, not in PM instructions.
+            # This ensures each agent gets its own memory, not all memories embedded in PM.
 
             # Add dynamic agent capabilities section
             instructions += capabilities_section

claude_mpm/core/framework/loaders/agent_loader.py

@@ -115,7 +115,11 @@ class AgentLoader:
         return agents
 
     def discover_local_json_templates(self) -> Dict[str, Dict[str, Any]]:
-        """Discover local JSON agent templates from .claude-mpm/agents/ directories.
+        """Discover local JSON agent templates.
+
+        NOTE: This method is kept for backward compatibility but is deprecated.
+        The new architecture uses SOURCE (~/.claude-mpm/cache/agents/)
+        and DEPLOYMENT (.claude/agents/) locations only.
 
         Returns:
             Dictionary mapping agent IDs to agent metadata
@@ -125,11 +129,10 @@ class AgentLoader:
         local_agents = {}
 
         # Check for local JSON templates in priority order
+        # NOTE: These directories are deprecated in the simplified architecture
         template_dirs = [
-            Path.cwd()
-            / ".claude-mpm"
-            / "agents",  # Project local agents (highest priority)
-            Path.home() / ".claude-mpm" / "agents",  # User local agents
+            Path.cwd() / ".claude-mpm" / "agents",  # Deprecated: Project local agents
+            Path.home() / ".claude-mpm" / "agents",  # Deprecated: User local agents
         ]
 
         for priority, template_dir in enumerate(template_dirs):

claude_mpm/core/framework/loaders/instruction_loader.py

@@ -88,39 +88,80 @@ class InstructionLoader:
                 self.packaged_loader.framework_last_modified
             )
 
+    def _extract_version(self, file_content: str) -> int:
+        """Extract version number from PM_INSTRUCTIONS_VERSION comment.
+
+        Args:
+            file_content: Content of the file to extract version from
+
+        Returns:
+            Version number as integer, or 0 if not found
+        """
+        import re
+
+        match = re.search(r"PM_INSTRUCTIONS_VERSION:\s*(\d+)", file_content)
+        if match:
+            return int(match.group(1))
+        return 0  # No version = oldest
+
     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)
+        1. Deployed compiled file: .claude-mpm/PM_INSTRUCTIONS_DEPLOYED.md (if version >= source)
         2. Source file (development): src/claude_mpm/agents/PM_INSTRUCTIONS.md
         3. Legacy file (backward compat): src/claude_mpm/agents/INSTRUCTIONS.md
 
+        Version validation ensures deployed file is never stale compared to source.
+
         Args:
             content: Dictionary to update with framework instructions
         """
+        # Define source path for version checking
+        pm_instructions_path = (
+            self.framework_path / "src" / "claude_mpm" / "agents" / "PM_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
+            # Validate version before using deployed file
+            deployed_content = deployed_path.read_text()
+            deployed_version = self._extract_version(deployed_content)
+
+            # Check source version for comparison
+            if pm_instructions_path.exists():
+                source_content = pm_instructions_path.read_text()
+                source_version = self._extract_version(source_content)
+
+                if deployed_version < source_version:
+                    self.logger.warning(
+                        f"Deployed PM instructions v{deployed_version:04d} is stale, "
+                        f"source is v{source_version:04d}. Using source instead."
+                    )
+                    # Fall through to source loading - don't return early
+                else:
+                    # Version OK, use deployed
+                    content["framework_instructions"] = deployed_content
+                    content["loaded"] = True
+                    self.logger.info(
+                        f"Loaded PM_INSTRUCTIONS_DEPLOYED.md v{deployed_version:04d} from .claude-mpm/"
+                    )
+                    return  # Stop here - deployed version is current
+            else:
+                # Source doesn't exist, use deployed even without version check
+                content["framework_instructions"] = deployed_content
                 content["loaded"] = True
                 self.logger.info("Loaded PM_INSTRUCTIONS_DEPLOYED.md from .claude-mpm/")
-                return  # Stop here - deployed version takes precedence
+                return
 
         # PRIORITY 2: Development mode - load from source PM_INSTRUCTIONS.md
-        pm_instructions_path = (
-            self.framework_path / "src" / "claude_mpm" / "agents" / "PM_INSTRUCTIONS.md"
-        )
         framework_instructions_path = (
             self.framework_path / "src" / "claude_mpm" / "agents" / "INSTRUCTIONS.md"
         )
 
-        # Try loading new consolidated file
+        # Try loading new consolidated file (pm_instructions_path already defined above)
         if pm_instructions_path.exists():
             loaded_content = self.file_loader.try_load_file(
                 pm_instructions_path, "source PM_INSTRUCTIONS.md (development mode)"

claude_mpm/core/framework_loader.py

@@ -255,10 +255,12 @@ class FrameworkLoader:
         """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"]
-        if "agent_memories" in memories:
-            content["agent_memories"] = memories["agent_memories"]
+        # NOTE: agent_memories are no longer loaded for PM instructions
+        # They are injected per-agent at deployment time
 
     # === Agent Discovery Methods ===
 

claude_mpm/core/logger.py

@@ -175,6 +175,19 @@ def setup_logging(
     Returns:
         Configured logger
     """
+    # Detect deployment context for install-type-aware defaults
+    if level == "INFO":  # Only override default, not explicit settings
+        from claude_mpm.core.unified_paths import DeploymentContext, PathContext
+
+        context = PathContext.detect_deployment_context()
+        if context in (
+            DeploymentContext.DEVELOPMENT,
+            DeploymentContext.EDITABLE_INSTALL,
+        ):
+            level = "INFO"  # Development: verbose logging
+        else:
+            level = "OFF"  # Production installs: silent by default
+
     logger = logging.getLogger(name)
 
     # Handle OFF level

claude_mpm/core/optimized_startup.py

@@ -165,6 +165,9 @@ class OptimizedStartup:
             # Just setup agent registry, load on demand
             self._setup_agent_registry()
 
+        # Verify PM skills after agent setup (non-blocking)
+        self._verify_pm_skills()
+
         elapsed = time.time() - phase_start
         self.metrics.phases["agents"] = elapsed
         self.metrics.agent_time = elapsed
@@ -198,6 +201,62 @@ class OptimizedStartup:
 
         return self.metrics
 
+    def _verify_pm_skills(self) -> None:
+        """Verify PM skills are deployed. Non-blocking with warnings."""
+        try:
+            from claude_mpm.services.pm_skills_deployer import PMSkillsDeployerService
+
+            deployer = PMSkillsDeployerService()
+            project_dir = Path.cwd()
+
+            result = deployer.verify_pm_skills(project_dir)
+
+            if not result.verified:
+                for warning in result.warnings:
+                    self.logger.warning(warning)
+
+                # Check if auto-deploy is enabled
+                if self._should_auto_deploy_pm_skills():
+                    self.logger.info("Auto-deploying PM skills...")
+                    deploy_result = deployer.deploy_pm_skills(project_dir)
+                    if deploy_result.success:
+                        self.logger.info(
+                            f"PM skills deployed: {len(deploy_result.deployed)} deployed, "
+                            f"{len(deploy_result.skipped)} skipped"
+                        )
+                    else:
+                        self.logger.warning(
+                            f"PM skills deployment had errors: {len(deploy_result.errors)}"
+                        )
+            else:
+                # Count skills from registry
+                registry = deployer._load_registry(project_dir)
+                skill_count = len(registry.get("skills", []))
+                self.logger.debug(f"PM skills verified: {skill_count} skills")
+
+        except ImportError:
+            self.logger.debug("PM skills deployer not available")
+        except Exception as e:
+            self.logger.warning(f"PM skills verification failed: {e}")
+
+    def _should_auto_deploy_pm_skills(self) -> bool:
+        """Check if auto-deploy is enabled via config.
+
+        Returns:
+            True if auto-deploy should be performed (default: True for convenience)
+        """
+        # Default to True for convenience - PM skills are essential for PM agents
+        # Users can disable by setting environment variable or config
+        import os
+
+        # Check environment variable override
+        env_disable = os.environ.get("CLAUDE_MPM_DISABLE_AUTO_DEPLOY_PM_SKILLS", "").lower()
+        if env_disable in ("1", "true", "yes"):
+            return False
+
+        # Default to enabled
+        return True
+
     def _setup_logging(self):
         """Setup basic logging (critical path)."""
         # Minimal logging setup - already handled by logger module