"""Create recovery_planner
Generated by Phi-Octopus Eden
2025-11-07 03:24:37.643706
"""

```python
from typing import Callable, Any


class RecoveryPlanner:
    """
    A class designed to manage limited error recovery strategies in a system.
    
    Attributes:
        strategy_map (dict): Maps exception types to their respective handling functions.
        
    Methods:
        add_strategy: Adds a new error handling strategy.
        execute_recovery_plan: Executes the appropriate recovery plan for an error.
    """
    
    def __init__(self):
        self.strategy_map = {}
    
    def add_strategy(self, exception_type: type, handler: Callable[[Exception], Any]) -> None:
        """Add or override a strategy to handle specific exceptions.
        
        Args:
            exception_type (type): The type of the exception to catch.
            handler (Callable[[Exception], Any]): The function to call when catching that exception.
        """
        self.strategy_map[exception_type] = handler
    
    def execute_recovery_plan(self, e: Exception) -> None:
        """Look up and execute the recovery strategy for a given exception type.
        
        Args:
            e (Exception): The caught exception instance.
            
        Raises:
            Exception: If no recovery strategy is defined for the given exception type.
        """
        handler = self.strategy_map.get(type(e))
        if handler is None:
            raise Exception(f"No recovery strategy for {type(e).__name__}")
        
        print(f"Executing recovery plan for {type(e).__name__}...")
        handler(e)


# Example usage
def handle_file_error(e: Exception) -> None:
    """Example file handling error recovery."""
    print("Failed to read file. Attempting to recover...")

def main():
    planner = RecoveryPlanner()
    
    # Adding strategies for specific exceptions
    planner.add_strategy(FileNotFoundError, handle_file_error)
    
    try:
        with open("non_existent_file.txt", "r") as f:
            content = f.read()
    except FileNotFoundError as e:
        planner.execute_recovery_plan(e)  # This call is redundant due to exception handling, but demonstrates usage

if __name__ == "__main__":
    main()
```

This code creates a `RecoveryPlanner` class that manages error recovery strategies for specific exceptions. It includes an example of adding a strategy and using it within the `main` function.