ulated_variable: str
    expected_effect_size: float
    control_variables: List[str]
    counterfactual_outcome: Optional[float] = None
    confidence_interval: Optional[List[float]] = None
    cost_estimate: Optional[float] = None
    time_to_execute: Optional[int] = None

@dataclass
class CausalEffectEstimate:
    """Causal effect estimate with confidence intervals"""
    estimated_effect: float
    lower_confidence: float
    upper_confidence: float
    confidence_level: float

class CausalInferenceEngine:
    """
    Engine for causal inference and intervention planning
    
    Example usage:
        engine = CausalInferenceEngine()
        
        # Add knowledge about causal relationships
        engine.learn_causal_graph(
            "treatment -> outcome",
            effect_size=0.8,
            confidence=0.95
        )
        
        # Plan intervention
        plan = engine.plan_intervention(
            target_variable="outcome",
            manipulated_variable="treatment"
        )
        
        print(asdict(plan))
    """
    
    def __init__(self):
        self.causal_graph = {}  # type: Dict[str, List[Dict[str, Any]]]
        self.confidence_intervals = {}  # type: Dict[str, Dict[str, float]]
        self.logger = logging.getLogger(__name__)
        self.start_time = datetime.now()
        
    def add_causal_edge(self, edge: str, effect_size: float, confidence: float):
        """
        Manually add a causal edge with effect size and confidence
        
        Args:
            edge (str): E.g. "treatment -> outcome"
            effect_size (float): Effect size [-1.0, 1.0]
            confidence (float): Confidence level [0.0, 1.0]
        """
        parts = edge.split(" -> ")
        if len(parts) != 2:
            raise ValueError(f"Invalid edge format: {edge}")
            
        from_var, to_var = parts
        
        self.causal_graph.setdefault(from_var, [])
        self.causal_graph[from_var].append({
            "to": to_var,
            "effect_size": effect_size,
            "confidence": confidence
        })
        
        # Store confidence intervals
        if to_var not in self.confidence_intervals:
            self.confidence_intervals[to_var] = {}
        self.confidence_intervals[to_var][from_var] = confidence
    
    def learn_causal_graph(self, causal_model: str, effect_size: float, confidence: float):
        """
        Learn causal relationships from models or data
        
        Args:
            causal_model (str): E.g. "treatment -> outcome"
            effect_size (float): Effect size [-1.0, 1.0]
            confidence (float): Confidence level [0.0, 1.0]
        """
        try:
            self.add_causal_edge(causal_model, effect_size, confidence)
            logging.info(f"Learned causal edge: {causal_model}")
        except Exception as e:
            logging.error(f"Failed to learn causal edge: {e}")
            
    def plan_intervention(self, target_variable: str, manipulated_variable: str) -> InterventionPlan:
        """
        Plan an