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

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -21,19 +21,29 @@ from claude_mpm.core.logging_config import get_logger
 
 from .agent_discovery_service import AgentDiscoveryService
 from .agent_version_manager import AgentVersionManager
+from .remote_agent_discovery_service import RemoteAgentDiscoveryService
 
 
 class MultiSourceAgentDeploymentService:
     """Service for deploying agents from multiple sources with version comparison.
 
     This service ensures that the highest version of each agent is deployed,
-    regardless of whether it comes from system templates, project agents, or
-    user agents.
+    regardless of whether it comes from system templates, project agents,
+    user agents, or remote agents.
+
+    4-Tier Agent Discovery:
+    1. System templates (lowest priority) - Built-in agents
+    2. User agents (DEPRECATED) - User-level customizations (~/.claude-mpm/agents/)
+    3. Remote agents - Agents cached from GitHub
+    4. Project agents (highest priority) - Project-specific customizations
 
     WHY: The current system processes agents from a single source at a time,
     which can result in lower version agents being deployed if they exist in
     a higher priority source. This service fixes that by comparing versions
     across all sources.
+
+    DEPRECATION: User-level agents (~/.claude-mpm/agents/) are deprecated and
+    will be removed in v5.0.0. Use project-level agents instead.
     """
 
     def __init__(self):
@@ -46,18 +56,30 @@ class MultiSourceAgentDeploymentService:
         system_templates_dir: Optional[Path] = None,
         project_agents_dir: Optional[Path] = None,
         user_agents_dir: Optional[Path] = None,
+        remote_agents_dir: Optional[Path] = None,
         working_directory: Optional[Path] = None,
     ) -> Dict[str, List[Dict[str, Any]]]:
-        """Discover agents from all available sources.
+        """Discover agents from all 4 tiers (system, user, remote, project).
+
+        Priority hierarchy (highest to lowest):
+        4. Project agents - Highest priority, project-specific customizations
+        3. Remote agents - GitHub-synced agents from cache
+        2. User agents - DEPRECATED, user-level customizations
+        1. System templates - Lowest priority, built-in agents
 
         Args:
             system_templates_dir: Directory containing system agent templates
             project_agents_dir: Directory containing project-specific agents
-            user_agents_dir: Directory containing user custom agents
+            user_agents_dir: Directory containing user custom agents (DEPRECATED)
+            remote_agents_dir: Directory containing cached remote agents
             working_directory: Current working directory for finding project agents
 
         Returns:
             Dictionary mapping agent names to list of agent info from different sources
+
+        Deprecation Warning:
+            User-level agents are deprecated and will show a warning if found.
+            Use 'claude-mpm agents migrate-to-project' to migrate them.
         """
         agents_by_name = {}
 
@@ -80,24 +102,53 @@ class MultiSourceAgentDeploymentService:
             if not user_agents_dir.exists():
                 user_agents_dir = None
 
-        # Discover agents from each source
+        if not remote_agents_dir:
+            # Check for remote agents in cache directory
+            cache_dir = Path.home() / ".claude-mpm" / "cache"
+            remote_agents_dir = cache_dir / "remote-agents"
+            if not remote_agents_dir.exists():
+                remote_agents_dir = None
+
+        # Discover agents from each source in priority order
+        # Note: We process in reverse priority order (system first) and build up the dictionary
+        # The select_highest_version_agents() method will handle the actual prioritization
         sources = [
             ("system", system_templates_dir),
-            ("project", project_agents_dir),
             ("user", user_agents_dir),
+            ("remote", remote_agents_dir),
+            ("project", project_agents_dir),
         ]
 
+        # Track if we found user agents for deprecation warning
+        user_agents_found = False
+
         for source_name, source_dir in sources:
             if source_dir and source_dir.exists():
                 self.logger.debug(
                     f"Discovering agents from {source_name} source: {source_dir}"
                 )
-                discovery_service = AgentDiscoveryService(source_dir)
-                # Pass log_discovery=False to avoid duplicate logging
-                agents = discovery_service.list_available_agents(log_discovery=False)
+
+                # Use appropriate discovery service based on source type
+                if source_name == "remote":
+                    # Remote agents are Markdown, use RemoteAgentDiscoveryService
+                    remote_service = RemoteAgentDiscoveryService(source_dir)
+                    agents = remote_service.discover_remote_agents()
+                else:
+                    # Other sources are JSON, use AgentDiscoveryService
+                    discovery_service = AgentDiscoveryService(source_dir)
+                    # Pass log_discovery=False to avoid duplicate logging
+                    agents = discovery_service.list_available_agents(
+                        log_discovery=False
+                    )
+
+                # Track user agents for deprecation warning
+                if source_name == "user" and agents:
+                    user_agents_found = True
 
                 for agent_info in agents:
-                    agent_name = agent_info.get("name")
+                    agent_name = agent_info.get("name") or agent_info.get(
+                        "metadata", {}
+                    ).get("name")
                     if not agent_name:
                         continue
 
@@ -116,6 +167,26 @@ class MultiSourceAgentDeploymentService:
                     f"Discovered {len(agents)} {source_name} agent templates from {source_dir.name}"
                 )
 
+        # Show deprecation warning if user agents found
+        if user_agents_found:
+            self.logger.warning(
+                "\n"
+                "⚠️  DEPRECATION WARNING: User-level agents found in ~/.claude-mpm/agents/\n"
+                "   User-level agent deployment is deprecated and will be removed in v5.0.0\n"
+                "\n"
+                "   Why this change?\n"
+                "   - Project isolation: Agents should be project-specific\n"
+                "   - Version control: Project agents can be versioned with your code\n"
+                "   - Team consistency: All team members use the same agents\n"
+                "\n"
+                "   Migration:\n"
+                "   1. Run: claude-mpm agents migrate-to-project\n"
+                "   2. Verify agents work in .claude-mpm/agents/\n"
+                "   3. Remove: rm -rf ~/.claude-mpm/agents/\n"
+                "\n"
+                "   Learn more: https://docs.claude-mpm.dev/agents/migration\n"
+            )
+
         return agents_by_name
 
     def select_highest_version_agents(
@@ -176,23 +247,47 @@ 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"
+                        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
+                            and other_agent["source"] != highest_version_agent["source"]
                         ):
-                            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']}"
+                            # Log info when versions are equal but different sources
+                            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
@@ -202,17 +297,19 @@ class MultiSourceAgentDeploymentService:
         system_templates_dir: Optional[Path] = None,
         project_agents_dir: Optional[Path] = None,
         user_agents_dir: Optional[Path] = None,
+        remote_agents_dir: Optional[Path] = None,
         working_directory: Optional[Path] = None,
         excluded_agents: Optional[List[str]] = None,
         config: Optional[Config] = None,
         cleanup_outdated: bool = True,
     ) -> Tuple[Dict[str, Path], Dict[str, str], Dict[str, Any]]:
-        """Get the highest version agents from all sources for deployment.
+        """Get the highest version agents from all 4 tiers for deployment.
 
         Args:
             system_templates_dir: Directory containing system agent templates
             project_agents_dir: Directory containing project-specific agents
-            user_agents_dir: Directory containing user custom agents
+            user_agents_dir: Directory containing user custom agents (DEPRECATED)
+            remote_agents_dir: Directory containing cached remote agents
             working_directory: Current working directory for finding project agents
             excluded_agents: List of agent names to exclude from deployment
             config: Configuration object for additional filtering
@@ -224,11 +321,12 @@ class MultiSourceAgentDeploymentService:
             - Dictionary mapping agent names to their source
             - Dictionary with cleanup results (removed, preserved, errors)
         """
-        # Discover all available agents
+        # Discover all available agents from 4 tiers
         agents_by_name = self.discover_agents_from_all_sources(
             system_templates_dir=system_templates_dir,
             project_agents_dir=project_agents_dir,
             user_agents_dir=user_agents_dir,
+            remote_agents_dir=remote_agents_dir,
             working_directory=working_directory,
         )
 
@@ -276,7 +374,21 @@ class MultiSourceAgentDeploymentService:
         agent_sources = {}
 
         for agent_name, agent_info in selected_agents.items():
-            template_path = Path(agent_info["path"])
+            # Defensive: Try multiple path fields for backward compatibility (ticket 1M-480)
+            # Priority: 'path' -> 'file_path' -> 'source_file'
+            path_str = (
+                agent_info.get("path")
+                or agent_info.get("file_path")
+                or agent_info.get("source_file")
+            )
+
+            if not path_str:
+                self.logger.warning(
+                    f"Agent '{agent_name}' missing path information (no 'path', 'file_path', or 'source_file' field)"
+                )
+                continue
+
+            template_path = Path(path_str)
             if template_path.exists():
                 # Use the file stem as the key for consistency
                 file_stem = template_path.stem
@@ -347,8 +459,20 @@ class MultiSourceAgentDeploymentService:
                 if agent_info["source"] != "user":
                     continue
 
+                # Defensive: Get path from agent_info (ticket 1M-480)
+                path_str = (
+                    agent_info.get("path")
+                    or agent_info.get("file_path")
+                    or agent_info.get("source_file")
+                )
+                if not path_str:
+                    self.logger.warning(
+                        f"User agent '{agent_name}' missing path information, skipping cleanup"
+                    )
+                    continue
+
                 # Safety check - ensure path is within user agents directory
-                user_agent_path = Path(agent_info["path"])
+                user_agent_path = Path(path_str)
                 try:
                     # Resolve paths to compare them safely
                     resolved_user_path = user_agent_path.resolve()
@@ -469,6 +593,47 @@ class MultiSourceAgentDeploymentService:
 
         return cleanup_results
 
+    def _is_user_created_agent(self, agent_file: Path) -> bool:
+        """Check if an agent is user-created based on metadata.
+
+        User agents are identified by:
+        - Lack of MPM authorship indicators
+        - Missing version or v0.0.0
+        - Certain naming patterns
+
+        Args:
+            agent_file: Path to the agent file to check
+
+        Returns:
+            True if the agent appears to be user-created, False otherwise
+        """
+        try:
+            content = agent_file.read_text()
+
+            # Check for MPM authorship indicators
+            mpm_indicators = [
+                "author: claude-mpm",
+                "author: 'claude-mpm'",
+                'author: "claude-mpm"',
+                "author: Claude MPM",
+                "Claude MPM Team",
+                "Generated by Claude MPM",
+                "claude-mpm-project",
+            ]
+
+            for indicator in mpm_indicators:
+                if indicator.lower() in content.lower():
+                    return False  # This is an MPM agent
+
+            # Check for version 0.0.0 (typical user agent default)
+            if "version: 0.0.0" in content or "version: '0.0.0'" in content:
+                return True
+
+            return True  # Default to user-created if no MPM indicators
+
+        except Exception:
+            return True  # Default to user-created if we can't read it
+
     def _apply_config_filters(
         self, selected_agents: Dict[str, Dict[str, Any]], config: Config
     ) -> Dict[str, Dict[str, Any]]:
@@ -534,7 +699,8 @@ class MultiSourceAgentDeploymentService:
             "needs_update": [],
             "up_to_date": [],
             "new_agents": [],
-            "orphaned_agents": [],  # Agents without templates
+            "orphaned_agents": [],  # System agents without templates
+            "user_agents": [],  # User-created agents (no templates required)
             "version_upgrades": [],
             "version_downgrades": [],
             "source_changes": [],
@@ -655,10 +821,11 @@ class MultiSourceAgentDeploymentService:
                 )
 
         # Check for orphaned agents (deployed but no template)
-        orphaned = self._detect_orphaned_agents_simple(
+        system_orphaned, user_orphaned = self._detect_orphaned_agents_simple(
             deployed_agents_dir, agents_to_deploy
         )
-        comparison_results["orphaned_agents"] = orphaned
+        comparison_results["orphaned_agents"] = system_orphaned
+        comparison_results["user_agents"] = user_orphaned
 
         # Log summary
         summary_parts = [
@@ -668,23 +835,29 @@ class MultiSourceAgentDeploymentService:
         ]
         if comparison_results["orphaned_agents"]:
             summary_parts.append(
-                f"{len(comparison_results['orphaned_agents'])} orphaned"
+                f"{len(comparison_results['orphaned_agents'])} system orphaned"
+            )
+        if comparison_results["user_agents"]:
+            summary_parts.append(
+                f"{len(comparison_results['user_agents'])} user agents"
             )
 
         self.logger.info(f"Version comparison complete: {', '.join(summary_parts)}")
 
+        # Don't log upgrades here - let the caller decide when to log
+        # This prevents repeated upgrade messages on every startup
         if comparison_results["version_upgrades"]:
             for upgrade in comparison_results["version_upgrades"]:
-                self.logger.info(
-                    f"  Upgrade: {upgrade['name']} "
+                self.logger.debug(
+                    f"  Upgrade available: {upgrade['name']} "
                     f"{upgrade['deployed_version']} -> {upgrade['new_version']} "
                     f"(from {upgrade['source']})"
                 )
 
         if comparison_results["source_changes"]:
             for change in comparison_results["source_changes"]:
-                self.logger.info(
-                    f"  Source change: {change['name']} "
+                self.logger.debug(
+                    f"  Source change available: {change['name']} "
                     f"from {change['from_source']} to {change['to_source']}"
                 )
 
@@ -698,10 +871,10 @@ class MultiSourceAgentDeploymentService:
                     f"{downgrade['template_version']} (keeping deployed version)"
                 )
 
-        # Log orphaned agents if found
+        # Log system orphaned agents if found
         if comparison_results["orphaned_agents"]:
             self.logger.info(
-                f"Found {len(comparison_results['orphaned_agents'])} orphaned agent(s) "
+                f"Found {len(comparison_results['orphaned_agents'])} system orphaned agent(s) "
                 f"(deployed without templates):"
             )
             for orphan in comparison_results["orphaned_agents"]:
@@ -710,6 +883,18 @@ class MultiSourceAgentDeploymentService:
                     f"(consider removing or creating a template)"
                 )
 
+        # Log user agents at debug level if found
+        if comparison_results["user_agents"]:
+            self.logger.debug(
+                f"Found {len(comparison_results['user_agents'])} user-created agent(s) "
+                f"(no templates required):"
+            )
+            for user_agent in comparison_results["user_agents"]:
+                self.logger.debug(
+                    f"  - {user_agent['name']} v{user_agent['version']} "
+                    f"(user-created agent)"
+                )
+
         return comparison_results
 
     def _infer_agent_source_from_context(
@@ -767,11 +952,13 @@ class MultiSourceAgentDeploymentService:
                 ):
                     # In development mode, unknown agents are likely system agents being tested
                     return "system"
-                if deployment_context == DeploymentContext.PIPX_INSTALL:
-                    # In pipx mode, unknown agents could be system agents
-                    # Check if agent follows system naming patterns
-                    if agent_name.count("-") <= 2 and len(agent_name) <= 20:
-                        return "system"
+                if (
+                    deployment_context == DeploymentContext.PIPX_INSTALL
+                    and agent_name.count("-") <= 2
+                    and len(agent_name) <= 20
+                ):
+                    # In pipx mode, check if agent follows system naming patterns
+                    return "system"
             except Exception:
                 pass
 
@@ -860,7 +1047,7 @@ class MultiSourceAgentDeploymentService:
 
     def _detect_orphaned_agents_simple(
         self, deployed_agents_dir: Path, agents_to_deploy: Dict[str, Path]
-    ) -> List[Dict[str, Any]]:
+    ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
         """Simple orphan detection that works with agents_to_deploy structure.
 
         Args:
@@ -868,12 +1055,13 @@ class MultiSourceAgentDeploymentService:
             agents_to_deploy: Dictionary mapping file stems to template paths
 
         Returns:
-            List of orphaned agent information
+            Tuple of (system_orphaned_agents, user_orphaned_agents)
         """
-        orphaned = []
+        system_orphaned = []
+        user_orphaned = []
 
         if not deployed_agents_dir.exists():
-            return orphaned
+            return system_orphaned, user_orphaned
 
         # agents_to_deploy already contains file stems as keys
         available_stems = set(agents_to_deploy.keys())
@@ -885,7 +1073,7 @@ class MultiSourceAgentDeploymentService:
             if agent_stem in available_stems:
                 continue
 
-            # This is an orphaned agent
+            # This is an orphaned agent - determine if it's user-created or system
             try:
                 deployed_content = deployed_file.read_text()
                 deployed_version, _, _ = (
@@ -899,11 +1087,19 @@ class MultiSourceAgentDeploymentService:
             except Exception:
                 version_str = "unknown"
 
-            orphaned.append(
-                {"name": agent_stem, "file": str(deployed_file), "version": version_str}
-            )
+            orphan_info = {
+                "name": agent_stem,
+                "file": str(deployed_file),
+                "version": version_str,
+            }
 
-        return orphaned
+            # Determine if this is a user-created agent
+            if self._is_user_created_agent(deployed_file):
+                user_orphaned.append(orphan_info)
+            else:
+                system_orphaned.append(orphan_info)
+
+        return system_orphaned, user_orphaned
 
     def cleanup_orphaned_agents(
         self, deployed_agents_dir: Path, dry_run: bool = True

claude_mpm/services/agents/deployment/pipeline/pipeline_executor.py

@@ -51,11 +51,11 @@ class DeploymentPipelineExecutor:
             try:
                 # Check if step should be executed
                 if not step.should_execute(context):
-                    self.logger.info(f"Skipping step {i+1}/{len(steps)}: {step.name}")
+                    self.logger.info(f"Skipping step {i + 1}/{len(steps)}: {step.name}")
                     skipped_steps.append(step.name)
                     continue
 
-                self.logger.info(f"Executing step {i+1}/{len(steps)}: {step.name}")
+                self.logger.info(f"Executing step {i + 1}/{len(steps)}: {step.name}")
 
                 # Execute the step
                 result = step.execute(context)

claude_mpm/services/agents/deployment/pipeline/steps/agent_processing_step.py

@@ -3,13 +3,14 @@
 import time
 from pathlib import Path
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.services.agents.deployment.processors import (
     AgentDeploymentContext,
     AgentDeploymentResult,
     AgentProcessor,
 )
 
-from .base_step import BaseDeploymentStep, StepResult, StepStatus
+from .base_step import BaseDeploymentStep, StepResult
 
 
 class AgentProcessingStep(BaseDeploymentStep):
@@ -37,7 +38,7 @@ class AgentProcessingStep(BaseDeploymentStep):
             if not context.template_files:
                 self.logger.warning("No template files to process")
                 return StepResult(
-                    status=StepStatus.SKIPPED,
+                    status=OperationResult.SKIPPED,
                     message="No template files found to process",
                     execution_time=time.time() - start_time,
                 )
@@ -103,13 +104,13 @@ class AgentProcessingStep(BaseDeploymentStep):
 
             # Determine step status
             if failed_count == 0:
-                status = StepStatus.SUCCESS
+                status = OperationResult.SUCCESS
                 message = f"Successfully processed {processed_count} agents in {execution_time:.3f}s"
             elif processed_count > 0:
-                status = StepStatus.WARNING
+                status = OperationResult.WARNING
                 message = f"Processed {processed_count} agents with {failed_count} failures in {execution_time:.3f}s"
             else:
-                status = StepStatus.FAILURE
+                status = OperationResult.FAILED
                 message = f"Failed to process any agents ({failed_count} failures) in {execution_time:.3f}s"
 
             self.logger.info(message)
@@ -127,7 +128,7 @@ class AgentProcessingStep(BaseDeploymentStep):
             context.add_error(error_msg)
 
             return StepResult(
-                status=StepStatus.FAILURE,
+                status=OperationResult.FAILED,
                 message=error_msg,
                 error=e,
                 execution_time=execution_time,
@@ -229,7 +230,7 @@ class AgentProcessingStep(BaseDeploymentStep):
                 cwd = Path.cwd()
                 if str(cwd) in template_str:
                     return "project"
-            except:
+            except Exception:
                 pass
 
         # Check if it's a user agent

claude_mpm/services/agents/deployment/pipeline/steps/base_step.py

@@ -2,26 +2,17 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from enum import Enum
 from typing import Optional
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logger import get_logger
 
 
-class StepStatus(Enum):
-    """Status of a pipeline step execution."""
-
-    SUCCESS = "success"
-    FAILURE = "failure"
-    SKIPPED = "skipped"
-    WARNING = "warning"
-
-
 @dataclass
 class StepResult:
     """Result of executing a pipeline step."""
 
-    status: StepStatus
+    status: OperationResult
     message: Optional[str] = None
     error: Optional[Exception] = None
     execution_time: Optional[float] = None
@@ -29,22 +20,22 @@ class StepResult:
     @property
     def is_success(self) -> bool:
         """Check if the step was successful."""
-        return self.status == StepStatus.SUCCESS
+        return self.status == OperationResult.SUCCESS
 
     @property
     def is_failure(self) -> bool:
         """Check if the step failed."""
-        return self.status == StepStatus.FAILURE
+        return self.status == OperationResult.FAILED
 
     @property
     def is_skipped(self) -> bool:
         """Check if the step was skipped."""
-        return self.status == StepStatus.SKIPPED
+        return self.status == OperationResult.SKIPPED
 
     @property
     def is_warning(self) -> bool:
         """Check if the step completed with warnings."""
-        return self.status == StepStatus.WARNING
+        return self.status == OperationResult.WARNING
 
 
 class BaseDeploymentStep(ABC):
@@ -67,7 +58,7 @@ class BaseDeploymentStep(ABC):
         self.logger = get_logger(f"{__name__}.{self.__class__.__name__}")
 
     @abstractmethod
-    def execute(self, context) -> StepResult:
+    def execute(self, context) -> "StepResult":
         """Execute this deployment step.
 
         Args:

claude_mpm/services/agents/deployment/pipeline/steps/configuration_step.py

@@ -3,8 +3,9 @@
 import time
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.enums import OperationResult
 
-from .base_step import BaseDeploymentStep, StepResult, StepStatus
+from .base_step import BaseDeploymentStep, StepResult
 
 
 class ConfigurationLoadStep(BaseDeploymentStep):
@@ -54,7 +55,7 @@ class ConfigurationLoadStep(BaseDeploymentStep):
             context.step_timings[self.name] = execution_time
 
             return StepResult(
-                status=StepStatus.SUCCESS,
+                status=OperationResult.SUCCESS,
                 message=f"Configuration loaded successfully in {execution_time:.3f}s",
                 execution_time=execution_time,
             )
@@ -68,7 +69,7 @@ class ConfigurationLoadStep(BaseDeploymentStep):
             context.add_error(error_msg)
 
             return StepResult(
-                status=StepStatus.FAILURE,
+                status=OperationResult.FAILED,
                 message=error_msg,
                 error=e,
                 execution_time=execution_time,