claude-mpm 4.2.51__py3-none-any.whl → 4.3.4__py3-none-any.whl

claude_mpm/core/framework_loader.py

@@ -639,7 +639,14 @@ class FrameworkLoader:
             self._load_packaged_framework_content(content)
         else:
             # Load from filesystem for development mode
-            # Load framework's INSTRUCTIONS.md
+            # Try new consolidated PM_INSTRUCTIONS.md first, fall back to INSTRUCTIONS.md
+            pm_instructions_path = (
+                self.framework_path
+                / "src"
+                / "claude_mpm"
+                / "agents"
+                / "PM_INSTRUCTIONS.md"
+            )
             framework_instructions_path = (
                 self.framework_path
                 / "src"
@@ -647,12 +654,25 @@ class FrameworkLoader:
                 / "agents"
                 / "INSTRUCTIONS.md"
             )
-            if framework_instructions_path.exists():
+
+            # Try loading new consolidated file first
+            if pm_instructions_path.exists():
                 loaded_content = self._try_load_file(
-                    framework_instructions_path, "framework INSTRUCTIONS.md"
+                    pm_instructions_path, "consolidated PM_INSTRUCTIONS.md"
                 )
                 if loaded_content:
                     content["framework_instructions"] = loaded_content
+                    self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md")
+            # Fall back to legacy file for backward compatibility
+            elif framework_instructions_path.exists():
+                loaded_content = self._try_load_file(
+                    framework_instructions_path, "framework INSTRUCTIONS.md (legacy)"
+                )
+                if loaded_content:
+                    content["framework_instructions"] = loaded_content
+                    self.logger.warning(
+                        "Using legacy INSTRUCTIONS.md - consider migrating to PM_INSTRUCTIONS.md"
+                    )
                     content["loaded"] = True
                     # Add framework version to content
                     if self.framework_version:
@@ -717,20 +737,33 @@ class FrameworkLoader:
                 return
 
         try:
-            # Load INSTRUCTIONS.md
-            instructions_content = self._load_packaged_file("INSTRUCTIONS.md")
-            if instructions_content:
-                content["framework_instructions"] = instructions_content
+            # Try new consolidated PM_INSTRUCTIONS.md first
+            pm_instructions_content = self._load_packaged_file("PM_INSTRUCTIONS.md")
+            if pm_instructions_content:
+                content["framework_instructions"] = pm_instructions_content
                 content["loaded"] = True
+                self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md from package")
                 # Extract and store version/timestamp metadata
                 self._extract_metadata_from_content(
-                    instructions_content, "INSTRUCTIONS.md"
+                    pm_instructions_content, "PM_INSTRUCTIONS.md"
                 )
-                if self.framework_version:
-                    content["instructions_version"] = self.framework_version
-                    content["version"] = self.framework_version
-                if self.framework_last_modified:
-                    content["instructions_last_modified"] = self.framework_last_modified
+            else:
+                # Fall back to legacy INSTRUCTIONS.md
+                instructions_content = self._load_packaged_file("INSTRUCTIONS.md")
+                if instructions_content:
+                    content["framework_instructions"] = instructions_content
+                    content["loaded"] = True
+                    self.logger.warning("Using legacy INSTRUCTIONS.md from package")
+                    # Extract and store version/timestamp metadata
+                    self._extract_metadata_from_content(
+                        instructions_content, "INSTRUCTIONS.md"
+                    )
+
+            if self.framework_version:
+                content["instructions_version"] = self.framework_version
+                content["version"] = self.framework_version
+            if self.framework_last_modified:
+                content["instructions_last_modified"] = self.framework_last_modified
 
             # Load BASE_PM.md
             base_pm_content = self._load_packaged_file("BASE_PM.md")
@@ -757,22 +790,37 @@ class FrameworkLoader:
     ) -> None:
         """Load framework content using importlib.resources fallback."""
         try:
-            # Load INSTRUCTIONS.md
-            instructions_content = self._load_packaged_file_fallback(
-                "INSTRUCTIONS.md", resources
+            # Try new consolidated PM_INSTRUCTIONS.md first
+            pm_instructions_content = self._load_packaged_file_fallback(
+                "PM_INSTRUCTIONS.md", resources
             )
-            if instructions_content:
-                content["framework_instructions"] = instructions_content
+            if pm_instructions_content:
+                content["framework_instructions"] = pm_instructions_content
                 content["loaded"] = True
+                self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md via fallback")
                 # Extract and store version/timestamp metadata
                 self._extract_metadata_from_content(
-                    instructions_content, "INSTRUCTIONS.md"
+                    pm_instructions_content, "PM_INSTRUCTIONS.md"
                 )
-                if self.framework_version:
-                    content["instructions_version"] = self.framework_version
-                    content["version"] = self.framework_version
-                if self.framework_last_modified:
-                    content["instructions_last_modified"] = self.framework_last_modified
+            else:
+                # Fall back to legacy INSTRUCTIONS.md
+                instructions_content = self._load_packaged_file_fallback(
+                    "INSTRUCTIONS.md", resources
+                )
+                if instructions_content:
+                    content["framework_instructions"] = instructions_content
+                    content["loaded"] = True
+                    self.logger.warning("Using legacy INSTRUCTIONS.md via fallback")
+                    # Extract and store version/timestamp metadata
+                    self._extract_metadata_from_content(
+                        instructions_content, "INSTRUCTIONS.md"
+                    )
+
+            if self.framework_version:
+                content["instructions_version"] = self.framework_version
+                content["version"] = self.framework_version
+            if self.framework_last_modified:
+                content["instructions_last_modified"] = self.framework_last_modified
 
             # Load BASE_PM.md
             base_pm_content = self._load_packaged_file_fallback("BASE_PM.md", resources)

claude_mpm/core/log_manager.py

@@ -29,6 +29,12 @@ from ..core.constants import SystemLimits
 
 logger = logging.getLogger(__name__)
 
+# Import cleanup utility for automatic cleanup
+try:
+    from ..utils.log_cleanup import run_cleanup_on_startup
+except ImportError:
+    run_cleanup_on_startup = None
+
 
 class LogManager:
     """
@@ -76,6 +82,9 @@ class LogManager:
         # Start background threads
         self._start_background_threads()
 
+        # Run automatic cleanup on startup if enabled
+        self._run_startup_cleanup()
+
     def _setup_logging_config(self):
         """Load and setup logging configuration from config."""
         logging_config = self.config.get("logging", {})
@@ -107,6 +116,49 @@ class LogManager:
         if not self.base_log_dir.is_absolute():
             self.base_log_dir = Path.cwd() / self.base_log_dir
 
+    def _run_startup_cleanup(self):
+        """Run automatic log cleanup on startup if enabled."""
+        if run_cleanup_on_startup is None:
+            return  # Cleanup utility not available
+
+        try:
+            # Get cleanup configuration
+            cleanup_config = self.config.get("log_cleanup", {})
+
+            # Check if automatic cleanup is enabled (default: True)
+            if not cleanup_config.get("auto_cleanup_enabled", True):
+                logger.debug("Automatic log cleanup is disabled")
+                return
+
+            # Convert hours to days for cleanup utility
+            cleanup_params = {
+                "auto_cleanup_enabled": True,
+                "session_retention_days": self.retention_hours.get("sessions", 168)
+                // 24,
+                "archive_retention_days": cleanup_config.get(
+                    "archive_retention_days", 30
+                ),
+                "log_retention_days": cleanup_config.get("log_retention_days", 14),
+            }
+
+            # Run cleanup in background thread to avoid blocking startup
+            def cleanup_task():
+                try:
+                    result = run_cleanup_on_startup(self.base_log_dir, cleanup_params)
+                    if result:
+                        logger.debug(
+                            f"Startup cleanup completed: "
+                            f"Removed {result.get('total_removed', 0)} items"
+                        )
+                except Exception as e:
+                    logger.debug(f"Startup cleanup failed: {e}")
+
+            cleanup_thread = Thread(target=cleanup_task, daemon=True)
+            cleanup_thread.start()
+
+        except Exception as e:
+            logger.debug(f"Could not run startup cleanup: {e}")
+
     def _start_background_threads(self):
         """Start background threads for async operations."""
         with self._lock:

claude_mpm/core/logging_utils.py

@@ -42,8 +42,10 @@ class LoggingConfig:
     ISO_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
 
     # File settings
-    MAX_BYTES = 10 * 1024 * 1024  # 10MB
+    MAX_BYTES = 5 * 1024 * 1024  # 5MB - lowered for better rotation testing
     BACKUP_COUNT = 5
+    ROTATION_INTERVAL = "midnight"  # Daily rotation at midnight
+    ROTATION_BACKUP_COUNT = 7  # Keep 7 days of daily logs
 
     # Component-specific log names
     COMPONENT_NAMES = {
@@ -129,30 +131,46 @@ class LoggerFactory:
         log_format: Optional[str] = None,
         date_format: Optional[str] = None,
     ) -> None:
-        """Set up file logging handler."""
+        """Set up file logging handlers with both size and time-based rotation."""
         if not cls._log_dir:
             return
 
         # Ensure log directory exists
         cls._log_dir.mkdir(parents=True, exist_ok=True)
 
-        # Create rotating file handler
+        formatter = logging.Formatter(
+            log_format or LoggingConfig.DETAILED_FORMAT,
+            date_format or LoggingConfig.DATE_FORMAT,
+        )
+
+        # 1. Size-based rotating file handler (for current active log)
         log_file = cls._log_dir / "claude_mpm.log"
-        file_handler = logging.handlers.RotatingFileHandler(
+        size_handler = logging.handlers.RotatingFileHandler(
             log_file,
             maxBytes=LoggingConfig.MAX_BYTES,
             backupCount=LoggingConfig.BACKUP_COUNT,
         )
-        file_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
-
-        file_formatter = logging.Formatter(
-            log_format or LoggingConfig.DETAILED_FORMAT,
-            date_format or LoggingConfig.DATE_FORMAT,
+        size_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
+        size_handler.setFormatter(formatter)
+        logging.getLogger().addHandler(size_handler)
+        cls._handlers["file"] = size_handler
+
+        # 2. Time-based rotating file handler (daily rotation)
+        daily_log_file = cls._log_dir / "claude_mpm_daily.log"
+        time_handler = logging.handlers.TimedRotatingFileHandler(
+            daily_log_file,
+            when=LoggingConfig.ROTATION_INTERVAL,
+            interval=1,
+            backupCount=LoggingConfig.ROTATION_BACKUP_COUNT,
         )
-        file_handler.setFormatter(file_formatter)
+        time_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
+        time_handler.setFormatter(formatter)
+
+        # Add suffix to rotated files (e.g., claude_mpm_daily.log.2024-09-18)
+        time_handler.suffix = "%Y-%m-%d"
 
-        logging.getLogger().addHandler(file_handler)
-        cls._handlers["file"] = file_handler
+        logging.getLogger().addHandler(time_handler)
+        cls._handlers["file_daily"] = time_handler
 
     @classmethod
     def get_logger(

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -30,6 +30,52 @@ class AgentTemplateBuilder:
         """Initialize the template builder."""
         self.logger = get_logger(__name__)
 
+    def normalize_tools_input(self, tools):
+        """Normalize various tool input formats to a consistent list.
+
+        Handles multiple input formats:
+        - None/empty: Returns default tools
+        - String: Splits by comma and strips whitespace
+        - List: Ensures all items are strings and strips whitespace
+        - Dict: Takes enabled tools (where value is True)
+
+        Args:
+            tools: Tools input in various formats (str, list, dict, or None)
+
+        Returns:
+            List of tool names, normalized and cleaned
+        """
+        default_tools = ["Read", "Write", "Edit", "Grep", "Glob", "Bash"]
+
+        # Handle None or empty
+        if not tools:
+            self.logger.debug("No tools provided, using defaults")
+            return default_tools
+
+        # Convert to list format
+        if isinstance(tools, str):
+            # Split by comma, strip whitespace
+            tool_list = [t.strip() for t in tools.split(",") if t.strip()]
+            self.logger.debug(f"Converted string tools '{tools}' to list: {tool_list}")
+        elif isinstance(tools, list):
+            # Ensure all items are strings and strip whitespace
+            tool_list = [str(t).strip() for t in tools if t and str(t).strip()]
+            self.logger.debug(f"Normalized list tools: {tool_list}")
+        elif isinstance(tools, dict):
+            # Handle dict format - take enabled tools
+            tool_list = [k for k, v in tools.items() if v]
+            self.logger.info(f"Converting dict tools format: {tools} -> {tool_list}")
+        else:
+            self.logger.warning(f"Unknown tools format: {type(tools)}, using defaults")
+            return default_tools
+
+        # Return processed list or defaults if empty
+        if not tool_list:
+            self.logger.debug("Tools list empty after processing, using defaults")
+            return default_tools
+
+        return tool_list
+
     def _load_base_agent_instructions(self, agent_type: str) -> str:
         """Load BASE instructions for a specific agent type.
 
@@ -138,13 +184,39 @@ class AgentTemplateBuilder:
             capabilities.get("tools") if isinstance(capabilities, dict) else None
         )
 
-        tools = (
+        # Get raw tools from various possible locations
+        raw_tools = (
             template_data.get("tools")
             or capabilities_tools
             or template_data.get("configuration_fields", {}).get("tools")
-            or ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
         )
 
+        # Normalize tools to a consistent list format
+        tools = self.normalize_tools_input(raw_tools)
+
+        # Log if we see non-standard tool names (info level, not warning)
+        standard_tools = {
+            "Read",
+            "Write",
+            "Edit",
+            "MultiEdit",  # File operations
+            "Grep",
+            "Glob",
+            "LS",  # Search and navigation
+            "Bash",
+            "BashOutput",
+            "KillShell",  # Command execution
+            "TodoWrite",
+            "ExitPlanMode",  # Task management
+            "WebSearch",
+            "WebFetch",  # Web operations
+            "NotebookRead",
+            "NotebookEdit",  # Jupyter notebook support
+        }
+        non_standard = [t for t in tools if t not in standard_tools]
+        if non_standard:
+            self.logger.info(f"Using non-standard tools: {non_standard}")
+
         # Extract model from template with fallback
         capabilities_model = (
             capabilities.get("model") if isinstance(capabilities, dict) else None
@@ -157,15 +229,8 @@ class AgentTemplateBuilder:
             or "sonnet"  # Default fallback
         )
 
-        # Convert tools list to comma-separated string (no spaces!)
-        tools_str = ",".join(tools) if isinstance(tools, list) else str(tools)
-
-        # Validate tools format - CRITICAL: No spaces allowed!
-        if ", " in tools_str:
-            self.logger.error(f"Tools contain spaces: '{tools_str}'")
-            raise ValueError(
-                f"Tools must be comma-separated WITHOUT spaces: {tools_str}"
-            )
+        # Convert tools list to comma-separated string (without spaces for compatibility)
+        tools_str = ",".join(tools)
 
         # Map model names to Claude Code format (as required)
         model_map = {
@@ -331,12 +396,20 @@ class AgentTemplateBuilder:
         base_instructions = self._load_base_agent_instructions(agent_type)
 
         # Get agent instructions from template data (primary) or base agent data (fallback)
-        agent_specific_instructions = (
-            template_data.get("instructions")
-            or base_agent_data.get("content")
-            or base_agent_data.get("instructions")
-            or "# Agent Instructions\n\nThis agent provides specialized assistance."
-        )
+        raw_instructions = template_data.get("instructions")
+
+        # Handle dictionary instructions format
+        if isinstance(raw_instructions, dict):
+            agent_specific_instructions = self._convert_instructions_dict_to_markdown(
+                raw_instructions
+            )
+        else:
+            agent_specific_instructions = (
+                raw_instructions
+                or base_agent_data.get("content")
+                or base_agent_data.get("instructions")
+                or "# Agent Instructions\n\nThis agent provides specialized assistance."
+            )
 
         # Combine BASE instructions with agent-specific instructions
         if base_instructions:
@@ -423,7 +496,8 @@ Only include memories that are:
         )
 
         # Get tools and model with fallbacks
-        tools = merged_config.get("tools", ["Read", "Write", "Edit"])
+        raw_tools = merged_config.get("tools")
+        tools = self.normalize_tools_input(raw_tools)
         model = merged_config.get("model", "sonnet")
 
         # Format tools as YAML list
@@ -890,3 +964,171 @@ tools:
 
         # Return as quoted string
         return f'"{escaped}"'
+
+    def _convert_instructions_dict_to_markdown(self, instructions_dict: dict) -> str:
+        """Convert complex instructions dictionary to markdown format.
+
+        Args:
+            instructions_dict: Dictionary containing structured instructions
+
+        Returns:
+            Formatted markdown string representing the instructions
+        """
+        if not instructions_dict:
+            return "# Agent Instructions\n\nThis agent provides specialized assistance."
+
+        markdown_parts = []
+
+        # Add primary role
+        if "primary_role" in instructions_dict:
+            markdown_parts.extend(["# Role", "", instructions_dict["primary_role"], ""])
+
+        # Add core identity
+        if "core_identity" in instructions_dict:
+            markdown_parts.extend(
+                ["## Core Identity", "", instructions_dict["core_identity"], ""]
+            )
+
+        # Add responsibilities
+        if "responsibilities" in instructions_dict:
+            markdown_parts.extend(["## Responsibilities", ""])
+
+            responsibilities = instructions_dict["responsibilities"]
+            if isinstance(responsibilities, list):
+                for resp in responsibilities:
+                    if isinstance(resp, dict):
+                        area = resp.get("area", "Unknown Area")
+                        tasks = resp.get("tasks", [])
+
+                        markdown_parts.extend([f"### {area}", ""])
+
+                        if isinstance(tasks, list):
+                            for task in tasks:
+                                markdown_parts.append(f"- {task}")
+
+                        markdown_parts.append("")
+                    else:
+                        markdown_parts.append(f"- {resp}")
+
+            markdown_parts.append("")
+
+        # Add analytical framework
+        if "analytical_framework" in instructions_dict:
+            framework = instructions_dict["analytical_framework"]
+            if isinstance(framework, dict):
+                markdown_parts.extend(["## Analytical Framework", ""])
+
+                for framework_area, framework_data in framework.items():
+                    markdown_parts.extend(
+                        [f"### {framework_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(framework_data, dict):
+                        for category, items in framework_data.items():
+                            markdown_parts.extend(
+                                [f"#### {category.replace('_', ' ').title()}", ""]
+                            )
+
+                            if isinstance(items, list):
+                                for item in items:
+                                    markdown_parts.append(f"- {item}")
+                            elif isinstance(items, str):
+                                markdown_parts.append(items)
+
+                            markdown_parts.append("")
+                    elif isinstance(framework_data, list):
+                        for item in framework_data:
+                            markdown_parts.append(f"- {item}")
+                        markdown_parts.append("")
+
+        # Add methodologies
+        if "methodologies" in instructions_dict:
+            methodologies = instructions_dict["methodologies"]
+            if isinstance(methodologies, dict):
+                markdown_parts.extend(["## Methodologies", ""])
+
+                for method_name, method_data in methodologies.items():
+                    markdown_parts.extend(
+                        [f"### {method_name.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(method_data, dict):
+                        for key, value in method_data.items():
+                            if isinstance(value, list):
+                                markdown_parts.extend(
+                                    [f"#### {key.replace('_', ' ').title()}", ""]
+                                )
+                                for item in value:
+                                    markdown_parts.append(f"- {item}")
+                                markdown_parts.append("")
+                            elif isinstance(value, str):
+                                markdown_parts.extend(
+                                    [
+                                        f"**{key.replace('_', ' ').title()}**: {value}",
+                                        "",
+                                    ]
+                                )
+
+        # Add quality standards
+        if "quality_standards" in instructions_dict:
+            standards = instructions_dict["quality_standards"]
+            if isinstance(standards, dict):
+                markdown_parts.extend(["## Quality Standards", ""])
+
+                for standard_area, standard_items in standards.items():
+                    markdown_parts.extend(
+                        [f"### {standard_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(standard_items, list):
+                        for item in standard_items:
+                            markdown_parts.append(f"- {item}")
+                    elif isinstance(standard_items, str):
+                        markdown_parts.append(standard_items)
+
+                    markdown_parts.append("")
+
+        # Add communication style
+        if "communication_style" in instructions_dict:
+            comm_style = instructions_dict["communication_style"]
+            if isinstance(comm_style, dict):
+                markdown_parts.extend(["## Communication Style", ""])
+
+                for style_area, style_items in comm_style.items():
+                    markdown_parts.extend(
+                        [f"### {style_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(style_items, list):
+                        for item in style_items:
+                            markdown_parts.append(f"- {item}")
+                    elif isinstance(style_items, str):
+                        markdown_parts.append(style_items)
+
+                    markdown_parts.append("")
+
+        # If no specific sections were found, convert as generic dict
+        if not markdown_parts:
+            markdown_parts = ["# Agent Instructions", ""]
+            for key, value in instructions_dict.items():
+                key_title = key.replace("_", " ").title()
+                if isinstance(value, str):
+                    markdown_parts.extend([f"## {key_title}", "", value, ""])
+                elif isinstance(value, list):
+                    markdown_parts.extend([f"## {key_title}", ""])
+                    for item in value:
+                        markdown_parts.append(f"- {item}")
+                    markdown_parts.append("")
+                elif isinstance(value, dict):
+                    markdown_parts.extend([f"## {key_title}", ""])
+                    # Simple dict formatting
+                    for subkey, subvalue in value.items():
+                        if isinstance(subvalue, str):
+                            markdown_parts.extend(
+                                [
+                                    f"**{subkey.replace('_', ' ').title()}**: {subvalue}",
+                                    "",
+                                ]
+                            )
+
+        return "\n".join(markdown_parts).strip()

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -176,24 +176,43 @@ class MultiSourceAgentDeploymentService:
                 # Log if a higher priority source was overridden by version
                 for other_agent in agent_versions:
                     if other_agent != highest_version_agent:
-                        self.version_manager.parse_version(
+                        # Parse both versions for comparison
+                        other_version = self.version_manager.parse_version(
                             other_agent.get("version", "0.0.0")
                         )
-                        if (
-                            other_agent["source"] == "project"
-                            and highest_version_agent["source"] == "system"
-                        ):
-                            self.logger.warning(
-                                f"Project agent '{agent_name}' v{other_agent['version']} "
-                                f"overridden by higher system version v{highest_version_agent['version']}"
-                            )
-                        elif other_agent["source"] == "user" and highest_version_agent[
-                            "source"
-                        ] in ["system", "project"]:
-                            self.logger.warning(
-                                f"User agent '{agent_name}' v{other_agent['version']} "
-                                f"overridden by higher {highest_version_agent['source']} version v{highest_version_agent['version']}"
-                            )
+                        highest_version = self.version_manager.parse_version(
+                            highest_version_agent.get("version", "0.0.0")
+                        )
+
+                        # Compare the versions
+                        version_comparison = self.version_manager.compare_versions(
+                            other_version, highest_version
+                        )
+
+                        # Only warn if the other version is actually lower
+                        if version_comparison < 0:
+                            if (
+                                other_agent["source"] == "project"
+                                and highest_version_agent["source"] == "system"
+                            ):
+                                self.logger.warning(
+                                    f"Project agent '{agent_name}' v{other_agent['version']} "
+                                    f"overridden by higher system version v{highest_version_agent['version']}"
+                                )
+                            elif other_agent["source"] == "user" and highest_version_agent[
+                                "source"
+                            ] in ["system", "project"]:
+                                self.logger.warning(
+                                    f"User agent '{agent_name}' v{other_agent['version']} "
+                                    f"overridden by higher {highest_version_agent['source']} version v{highest_version_agent['version']}"
+                                )
+                        elif version_comparison == 0:
+                            # Log info when versions are equal but different sources
+                            if other_agent["source"] != highest_version_agent["source"]:
+                                self.logger.info(
+                                    f"Using {highest_version_agent['source']} source for '{agent_name}' "
+                                    f"(same version v{highest_version_agent['version']} as {other_agent['source']} source)"
+                                )
 
         return selected_agents
 

claude_mpm/services/agents/local_template_manager.py

@@ -280,7 +280,6 @@ class LocalAgentTemplateManager:
             parent_agent=parent_agent,
         )
 
-
     def save_local_template(
         self, template: LocalAgentTemplate, tier: Optional[str] = None
     ) -> Path: