class MetaLazyLoader:
    """
    A meta-capability that implements lazy loading for other capabilities.
    
    This ensures that capabilities are built and initialized only when needed,
    improving efficiency and reducing unnecessary computations during the build process.
    """

    def __init__(self):
        self._built_capabilities = {}  # Stores already built capabilities
        self._loading_in_progress = {}  # Tracks if a capability is currently being built

    def __getattr__(self, name):
        """
        Lazy loads the requested capability when it's first accessed.
        
        If the capability hasn't been built yet, initializes and builds it. This method ensures that each capability
        is built only once to optimize performance.
        """
        if name in self._built_capabilities:
            return self._built_capabilities[name]
        
        # Check if we're already loading this capability to prevent multiple initializations
        if name in self._loading_in_progress:
            raise RecursionError("Circular dependency detected while building capability: " + name)
        
        self._loading_in_progress[name] = True
        
        try:
            # Build the capability
            capability = self.build_capability(name)
            
            # Store the built capability
            self._built_capabilities[name] = capability
            
            return capability
        except Exception as e:
            raise RuntimeError(f"Failed to build capability '{name}': {str(e)}")
        finally:
            del self._loading_in_progress[name]

    def build_capability(self, name):
        """
        Abstract method that must be implemented by subclasses.
        
        Handles the specific logic for building each capability. Subclasses should
        override this method to provide custom capability-building logic.
        """
        raise NotImplementedError("Subclass must implement build_capability method.")
    
    # Example implementation of a capability:
    def build_example_capability(self, name):
        """Example capability builder."""
        if name == 'example':
            return {
                'status': 'built',
                'message': 'Example capability is initialized successfully.'
            }
        else:
            raise AttributeError(f"Capability '{name}' not found.")

    # Additional helper methods for managing capabilities
    def has_capability(self, name):
        """
        Checks if a capability exists without initializing it.
        
        Args:
            name (str): The name of the capability to check.
            
        Returns:
            bool: True if the capability is known, False otherwise.
        """
        return hasattr(self.__class__, name) or name in self._built_capabilities

    def get_capability_status(self, name):
        """
        Gets the status of a capability's build process.
        
        Args:
            name (str): The name of the capability to check.
            
        Returns:
            str: Status message indicating if the capability is built, loading, or unknown.
        """
        if name in self._built_capabilities:
            return f"Capability '{name}' is already built."
        elif name in self._loading_in_progress:
            return f"Capability '{name}' is currently being loaded."
        else:
            return f"Capability '{name}' has not been requested yet."

    def __repr__(self):
        """
        Returns a string representation of the MetaLazyLoader instance.
        
        Shows which capabilities have been built and their current status.
        """
        built = ", ".join(self._built_capabilities.keys()) if self._built_capabilities else "None"
        loading = ", ".join(self._loading_in_progress.keys()) if self._loading_in_progress else "None"
        return f"MetaLazyLoader(builtCapabilities: {built}, currentlyLoading: {loading})"