"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 15:17:23.801490
"""

```python
from typing import List, Dict, Tuple

class ReasoningEngine:
    """
    A basic reasoning engine that can evaluate conditions and return a conclusion based on predefined rules.
    """

    def __init__(self):
        self.rules: Dict[str, Dict[str, bool]] = {}
    
    def add_rule(self, condition: str, rule: bool) -> None:
        """
        Add a new rule to the reasoning engine.

        :param condition: The condition string that will be evaluated.
        :param rule: The outcome of the evaluation (True or False).
        """
        self.rules[condition] = {"rule": rule}

    def evaluate(self, conditions: List[str]) -> Tuple[bool, str]:
        """
        Evaluate a list of conditions and return if all are true along with the result.

        :param conditions: A list of condition strings to be evaluated.
        :return: A tuple where the first element is True if all conditions are met or False otherwise,
                 and the second element is the explanation string detailing which rule(s) failed.
        """
        failure_explanation = ""
        for condition in conditions:
            if condition not in self.rules:
                return False, f"Rule '{condition}' does not exist."
            
            if not self.rules[condition]["rule"]:
                failure_explanation += f"Condition '{condition}' is false. "
        
        all_conditions_met = len(failure_explanation) == 0
        explanation = "All conditions are met." if all_conditions_met else failure_explanation.strip()
        return all_conditions_met, explanation

# Example usage:
reasoning_engine = ReasoningEngine()
reasoning_engine.add_rule("temperature > 30", True)
reasoning_engine.add_rule("humidity < 60", False)

conditions_to_evaluate = ["temperature > 30", "humidity < 60"]

result, explanation = reasoning_engine.evaluate(conditions_to_evaluate)
print(f"Result: {result}, Explanation: '{explanation}'")
```