"""Create error_monitor
Generated by Phi-Octopus Eden
2025-11-07 07:45:04.091314
"""

```python
from typing import Any, Dict


class ErrorMonitor:
    """
    A class for monitoring and handling errors in a limited recovery manner.

    Attributes:
        error_count: An integer representing the number of times an error has occurred.
        recovery_limit: An integer defining the maximum allowable errors before full shutdown is initiated.
        last_errors: A dictionary storing information about the most recent errors, key: timestamp, value: error_message.

    Methods:
        log_error: Logs an error message and updates the last_errors dictionary if within recovery limit.
        trigger_recovery: Checks for exceeding the recovery limit and initiates a limited recovery process.
        reset_monitor: Resets the monitor's state to initial conditions.
    """

    def __init__(self, recovery_limit: int = 3):
        """
        Initialize ErrorMonitor with default or provided recovery limit.

        Args:
            recovery_limit (int): Maximum number of errors before full shutdown is initiated. Default is 3.
        """
        self.error_count = 0
        self.recovery_limit = recovery_limit
        self.last_errors: Dict[str, Any] = {}

    def log_error(self, error_message: str, timestamp: str) -> None:
        """
        Log an error message and update the last_errors dictionary.

        Args:
            error_message (str): The error message to be logged.
            timestamp (str): Timestamp of when the error occurred.
        """
        if self.error_count < self.recovery_limit:
            self.last_errors[timestamp] = error_message
            self.error_count += 1

    def trigger_recovery(self) -> None:
        """
        Check if recovery limit is exceeded and initiate a limited recovery process.
        """
        if self.error_count >= self.recovery_limit:
            print("Recovery initiated due to excessive errors.")
            # Here you can add code for the actual recovery process
            self.reset_monitor()

    def reset_monitor(self) -> None:
        """
        Reset the monitor's state to initial conditions.
        """
        self.error_count = 0
        self.last_errors.clear()
        print("Monitor reset.")


# Example usage
if __name__ == "__main__":
    error_monitor = ErrorMonitor(recovery_limit=3)
    
    try:
        # Simulate errors in a function call
        def faulty_function():
            raise ValueError("Something went wrong!")
        
        for _ in range(4):
            faulty_function()
    except Exception as e:
        error_monitor.log_error(str(e), timestamp="2023-10-05 12:00:00")
    
    error_monitor.trigger_recovery()

    # Simulate normal operation
    try:
        for _ in range(5):
            faulty_function()
    except Exception as e:
        error_monitor.log_error(str(e), timestamp="2023-10-06 14:00:00")

```