Delete core

core/boundary_manager.py

@@ -1,321 +0,0 @@
-# core/boundary_manager.py
-"""
-Boundary Manager for ARF Demo - Enforces clear separation between real OSS and simulated Enterprise
-Ensures the audience always knows what's real vs simulated
-"""
-
-import logging
-from typing import Dict, Any, Tuple
-from dataclasses import dataclass
-from enum import Enum
-
-logger = logging.getLogger(__name__)
-
-class SystemMode(Enum):
-    """Clear system mode definitions"""
-    REAL_OSS_ADVISORY = "real_oss_advisory"  # Real ARF OSS package
-    SIMULATED_ENTERPRISE = "simulated_enterprise"  # Enterprise simulation
-    MOCK_FALLBACK = "mock_fallback"  # Mock when nothing is available
-
-@dataclass
-class SystemBoundary:
-    """Clear boundary definition with labels"""
-    mode: SystemMode
-    real_components: list[str]
-    simulated_components: list[str]
-    oss_license: str
-    enterprise_license: str
-    execution_allowed: bool
-    
-    def get_display_labels(self) -> Dict[str, str]:
-        """Get clear display labels for UI"""
-        base_labels = {
-            "system_mode": self.mode.value,
-            "oss_status": f"✅ REAL ARF OSS v3.3.7" if self.mode == SystemMode.REAL_OSS_ADVISORY else "⚠️ MOCK ARF",
-            "enterprise_status": f"🎭 SIMULATED Enterprise" if self.mode == SystemMode.SIMULATED_ENTERPRISE else "⚠️ MOCK Enterprise",
-            "execution_capability": "Advisory Only (Apache 2.0)" if not self.execution_allowed else "Autonomous Execution (Enterprise)",
-            "license_display": f"OSS: {self.oss_license} | Enterprise: {self.enterprise_license}",
-            "boundary_note": "OSS advises, Enterprise executes" if self.mode == SystemMode.SIMULATED_ENTERPRISE else "Mock mode for demo"
-        }
-        
-        # Add color coding
-        if self.mode == SystemMode.REAL_OSS_ADVISORY:
-            base_labels.update({
-                "oss_color": "#10b981",  # Green for real
-                "enterprise_color": "#f59e0b",  # Amber for simulated
-                "oss_icon": "✅",
-                "enterprise_icon": "🎭"
-            })
-        else:
-            base_labels.update({
-                "oss_color": "#64748b",  # Gray for mock
-                "enterprise_color": "#64748b",  # Gray for mock
-                "oss_icon": "⚠️",
-                "enterprise_icon": "⚠️"
-            })
-            
-        return base_labels
-
-class BoundaryManager:
-    """Manages system boundaries and ensures clear labeling"""
-    
-    def __init__(self):
-        self.current_boundary = None
-        self.installation_status = self._check_installation()
-        self._initialize_boundary()
-    
-    def _check_installation(self) -> Dict[str, Any]:
-        """Check what's really installed"""
-        # Simplified version - in real app this checks actual packages
-        try:
-            from core.true_arf_oss import TrueARFOSS
-            oss_available = True
-        except ImportError:
-            oss_available = False
-            
-        try:
-            from core.enterprise_simulation import EnterpriseFeatureSimulation
-            enterprise_available = True
-        except ImportError:
-            enterprise_available = False
-            
-        return {
-            "oss_available": oss_available,
-            "enterprise_available": enterprise_available,
-            "true_arf_version": "3.3.7" if oss_available else "mock"
-        }
-    
-    def _initialize_boundary(self):
-        """Initialize the system boundary based on what's available"""
-        installation = self.installation_status
-        
-        if installation["oss_available"]:
-            # Real OSS + Simulated Enterprise
-            self.current_boundary = SystemBoundary(
-                mode=SystemMode.REAL_OSS_ADVISORY,
-                real_components=["TrueARFOSS", "Detection Agent", "Recall Agent", "Decision Agent"],
-                simulated_components=["EnterpriseExecution", "RollbackGuarantees", "NovelExecutionProtocols"],
-                oss_license="Apache 2.0",
-                enterprise_license="SIMULATED (requires Commercial)",
-                execution_allowed=False  # OSS is advisory only
-            )
-            logger.info("✅ System initialized with REAL ARF OSS + SIMULATED Enterprise")
-            
-        elif installation["enterprise_available"]:
-            # Mock OSS + Simulated Enterprise (unlikely but possible)
-            self.current_boundary = SystemBoundary(
-                mode=SystemMode.SIMULATED_ENTERPRISE,
-                real_components=[],
-                simulated_components=["EnterpriseFeatures", "ExecutionProtocols"],
-                oss_license="MOCK",
-                enterprise_license="SIMULATED",
-                execution_allowed=True  # Simulated execution
-            )
-            logger.info("⚠️ System initialized with MOCK OSS + SIMULATED Enterprise")
-            
-        else:
-            # Complete mock mode
-            self.current_boundary = SystemBoundary(
-                mode=SystemMode.MOCK_FALLBACK,
-                real_components=[],
-                simulated_components=["AllComponents"],
-                oss_license="MOCK",
-                enterprise_license="MOCK",
-                execution_allowed=False
-            )
-            logger.info("⚠️ System initialized in MOCK FALLBACK mode")
-    
-    def get_boundary_badges(self) -> str:
-        """Get HTML badges showing clear boundaries"""
-        labels = self.current_boundary.get_display_labels()
-        
-        return f"""
-        <div style="display: flex; justify-content: center; gap: 10px; margin-top: 10px; flex-wrap: wrap;">
-            <span style="padding: 4px 12px; background: {labels['oss_color']}; 
-                        color: white; border-radius: 20px; font-size: 12px; font-weight: bold; 
-                        display: flex; align-items: center; gap: 6px;">
-                {labels['oss_icon']} {labels['oss_status']}
-            </span>
-            <span style="padding: 4px 12px; background: {labels['enterprise_color']}; 
-                        color: white; border-radius: 20px; font-size: 12px; font-weight: bold;
-                        display: flex; align-items: center; gap: 6px;">
-                {labels['enterprise_icon']} {labels['enterprise_status']}
-            </span>
-            <span style="padding: 4px 12px; background: #3b82f6; 
-                        color: white; border-radius: 20px; font-size: 12px; font-weight: bold;">
-                {labels['execution_capability']}
-            </span>
-        </div>
-        """
-    
-    def get_agent_html(self, agent_name: str, is_real: bool = True, status: str = "Active") -> str:
-        """Get agent HTML with clear boundary indicators"""
-        icons = {
-            "Detection": "🕵️‍♂️",
-            "Recall": "🧠",
-            "Decision": "🎯"
-        }
-        
-        real_badge = """
-        <div style="position: absolute; top: -8px; right: -8px; padding: 2px 8px; background: #10b981; 
-                    color: white; border-radius: 12px; font-size: 10px; font-weight: bold; z-index: 10;
-                    border: 2px solid white; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-            REAL ARF
-        </div>
-        """ if is_real else """
-        <div style="position: absolute; top: -8px; right: -8px; padding: 2px 8px; background: #f59e0b; 
-                    color: white; border-radius: 12px; font-size: 10px; font-weight: bold; z-index: 10;
-                    border: 2px solid white; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-            DEMO MODE
-        </div>
-        """
-        
-        border_color = "#10b981" if is_real else "#f59e0b"
-        background = "#f0fdf4" if is_real else "#fef3c7"
-        
-        return f"""
-        <div style="position: relative;">
-            {real_badge}
-            <div style="border: 3px solid {border_color}; border-radius: 16px; padding: 20px; 
-                       background: {background}; text-align: center; min-height: 200px; 
-                       display: flex; flex-direction: column; align-items: center; justify-content: center;">
-                <div style="font-size: 42px; margin-bottom: 15px; opacity: 0.9;">{icons.get(agent_name, '🤖')}</div>
-                <div style="width: 100%;">
-                    <h4 style="margin: 0 0 10px 0; font-size: 18px; color: #1e293b; font-weight: 600;">{agent_name} Agent</h4>
-                    <p style="font-size: 14px; color: #475569; margin-bottom: 15px; line-height: 1.5;">
-                        Status: <strong>{status}</strong><br>
-                        <span style="font-size: 12px; color: {'#059669' if is_real else '#d97706'}">
-                            {'Running on REAL ARF OSS v3.3.7' if is_real else 'Running in DEMO MODE'}
-                        </span>
-                    </p>
-                    <div style="display: inline-block; padding: 8px 20px; background: linear-gradient(135deg, {border_color} 0%, {border_color}88 100%); 
-                               border-radius: 20px; font-size: 13px; font-weight: bold; color: white; 
-                               text-transform: uppercase; letter-spacing: 0.5px; margin-top: 10px;">
-                        {'ACTIVE (REAL)' if is_real else 'SIMULATED'}
-                    </div>
-                </div>
-            </div>
-        </div>
-        """
-    
-    def get_execution_boundary_html(self, action: str, is_simulated: bool = True) -> str:
-        """Get clear execution boundary indicator"""
-        if is_simulated:
-            return f"""
-            <div style="border: 3px dashed #f59e0b; border-radius: 16px; padding: 25px; 
-                       background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
-                       text-align: center; margin: 20px 0;">
-                <div style="font-size: 36px; margin-bottom: 15px;">🎭</div>
-                <h4 style="margin: 0 0 12px 0; font-size: 20px; color: #92400e; font-weight: 700;">
-                    SIMULATED ENTERPRISE EXECUTION
-                </h4>
-                <p style="font-size: 15px; color: #92400e; margin-bottom: 15px; line-height: 1.6;">
-                    <strong>Action:</strong> {action}<br>
-                    <strong>Mode:</strong> Enterprise Simulation (not real execution)<br>
-                    <strong>Boundary:</strong> OSS advises → Enterprise would execute
-                </p>
-                <div style="display: inline-block; padding: 10px 24px; background: #92400e; 
-                           border-radius: 20px; font-size: 14px; font-weight: bold; color: white; 
-                           text-transform: uppercase; letter-spacing: 1px;">
-                    DEMO BOUNDARY
-                </div>
-                <p style="font-size: 13px; color: #92400e; margin-top: 15px; font-style: italic;">
-                    In production, Enterprise edition would execute against real infrastructure
-                </p>
-            </div>
-            """
-        else:
-            return f"""
-            <div style="border: 3px solid #10b981; border-radius: 16px; padding: 25px; 
-                       background: linear-gradient(135deg, #f0fdf4 0%, #bbf7d0 100%);
-                       text-align: center; margin: 20px 0;">
-                <div style="font-size: 36px; margin-bottom: 15px;">⚡</div>
-                <h4 style="margin: 0 0 12px 0; font-size: 20px; color: #065f46; font-weight: 700;">
-                    REAL ENTERPRISE EXECUTION
-                </h4>
-                <p style="font-size: 15px; color: #065f46; margin-bottom: 15px; line-height: 1.6;">
-                    <strong>Action:</strong> {action}<br>
-                    <strong>Mode:</strong> Enterprise Autonomous<br>
-                    <strong>Boundary:</strong> Real execution with safety guarantees
-                </p>
-                <div style="display: inline-block; padding: 10px 24px; background: #065f46; 
-                           border-radius: 20px; font-size: 14px; font-weight: bold; color: white; 
-                           text-transform: uppercase; letter-spacing: 1px;">
-                    ENTERPRISE+
-                </div>
-            </div>
-            """
-    
-    def get_demo_narrative(self, phase: str) -> str:
-        """Get narrative text for each demo phase"""
-        narratives = {
-            "introduction": """
-            <div style="background: #f8fafc; border-radius: 12px; padding: 20px; margin: 20px 0; border-left: 4px solid #3b82f6;">
-                <h4 style="margin: 0 0 10px 0; color: #1e293b;">🎯 Demo Introduction</h4>
-                <p style="margin: 0; color: #475569; font-size: 14px; line-height: 1.6;">
-                    This demo shows the <strong>clear architectural boundary</strong> between ARF OSS (real advisory intelligence) 
-                    and ARF Enterprise (simulated autonomous execution). We're showing what happens in production, 
-                    not hiding behind mock data.
-                </p>
-            </div>
-            """,
-            
-            "oss_analysis": """
-            <div style="background: #f0fdf4; border-radius: 12px; padding: 20px; margin: 20px 0; border-left: 4px solid #10b981;">
-                <h4 style="margin: 0 0 10px 0; color: #065f46;">🧠 Real OSS Intelligence</h4>
-                <p style="margin: 0; color: #047857; font-size: 14px; line-height: 1.6;">
-                    ARF OSS v3.3.7 is <strong>analyzing the incident in real-time</strong>. This is not a mock - it's the actual 
-                    ARF OSS package running detection, recall, and decision agents. Notice the confidence scores 
-                    and reasoning chain.
-                </p>
-            </div>
-            """,
-            
-            "enterprise_simulation": """
-            <div style="background: #fef3c7; border-radius: 12px; padding: 20px; margin: 20px 0; border-left: 4px solid #f59e0b;">
-                <h4 style="margin: 0 0 10px 0; color: #92400e;">🎭 Enterprise Simulation Boundary</h4>
-                <p style="margin: 0; color: #b45309; font-size: 14px; line-height: 1.6;">
-                    This is where we <strong>simulate Enterprise execution</strong>. In production, Enterprise would:
-                    1. Validate safety constraints, 2. Execute with rollback guarantees, 3. Update the learning engine.
-                    We're showing the value proposition without real infrastructure access.
-                </p>
-            </div>
-            """,
-            
-            "conclusion": """
-            <div style="background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%); border-radius: 12px; padding: 20px; margin: 20px 0; border: 2px solid #3b82f6;">
-                <h4 style="margin: 0 0 10px 0; color: #1e293b;">✅ Architecture Validated</h4>
-                <p style="margin: 0; color: #475569; font-size: 14px; line-height: 1.6;">
-                    <strong>What we demonstrated:</strong><br>
-                    • Real ARF OSS intelligence (advisory)<br>
-                    • Clear execution boundary (OSS vs Enterprise)<br>
-                    • Simulated Enterprise value proposition<br>
-                    • Production-ready architecture pattern<br><br>
-                    This isn't AI theater - it's a production-grade reliability system with honest boundaries.
-                </p>
-            </div>
-            """
-        }
-        
-        return narratives.get(phase, "")
-    
-    def validate_transition(self, from_mode: SystemMode, to_mode: SystemMode) -> Tuple[bool, str]:
-        """Validate mode transitions (e.g., can't go from mock to real execution)"""
-        transitions = {
-            (SystemMode.REAL_OSS_ADVISORY, SystemMode.SIMULATED_ENTERPRISE): (True, "Valid: Real OSS to Simulated Enterprise"),
-            (SystemMode.MOCK_FALLBACK, SystemMode.SIMULATED_ENTERPRISE): (True, "Valid: Mock to Simulated Enterprise"),
-            (SystemMode.SIMULATED_ENTERPRISE, SystemMode.REAL_OSS_ADVISORY): (False, "Invalid: Can't go from Enterprise simulation back to OSS in demo"),
-        }
-        
-        result = transitions.get((from_mode, to_mode), (True, "Valid transition"))
-        return result
-
-# Singleton instance
-_boundary_manager = None
-
-def get_boundary_manager() -> BoundaryManager:
-    """Get singleton BoundaryManager instance"""
-    global _boundary_manager
-    if _boundary_manager is None:
-        _boundary_manager = BoundaryManager()
-    return _boundary_manager

core/calculators.py

@@ -1,348 +0,0 @@
-"""
-Enhanced ROI calculators and business logic with Monte Carlo simulation
-"""
-
-from typing import Dict, List, Any, Tuple
-import numpy as np
-import logging
-from dataclasses import dataclass
-from enum import Enum
-from config.settings import settings
-
-logger = logging.getLogger(__name__)
-
-
-class ROIConfidence(Enum):
-    """Confidence levels for ROI predictions"""
-    HIGH = "High"
-    MEDIUM = "Medium"
-    LOW = "Low"
-
-
-@dataclass
-class ROIScenarioResult:
-    """Result of a single ROI scenario calculation"""
-    scenario_name: str
-    annual_impact: float
-    enterprise_cost: float
-    savings: float
-    roi_multiplier: float
-    roi_percentage: float
-    payback_months: float
-    confidence: ROIConfidence
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary"""
-        return {
-            "scenario_name": self.scenario_name,
-            "annual_impact": f"${self.annual_impact:,.0f}",
-            "enterprise_cost": f"${self.enterprise_cost:,.0f}",
-            "savings": f"${self.savings:,.0f}",
-            "roi_multiplier": f"{self.roi_multiplier:.1f}×",
-            "roi_percentage": f"{self.roi_percentage:.0f}%",
-            "payback_months": f"{self.payback_months:.1f}",
-            "confidence": self.confidence.value
-        }
-
-
-class EnhancedROICalculator:
-    """Investor-grade ROI calculator with Monte Carlo simulation"""
-    
-    def __init__(self):
-        self.engineer_hourly_rate = settings.engineer_hourly_rate
-        self.engineer_annual_cost = settings.engineer_annual_cost
-        self.default_savings_rate = settings.default_savings_rate
-    
-    def calculate_comprehensive_roi(self, monthly_incidents: int, 
-                                   avg_impact: float, team_size: int) -> Dict[str, Any]:
-        """
-        Calculate multi-scenario ROI analysis with Monte Carlo simulation
-        
-        Args:
-            monthly_incidents: Average incidents per month
-            avg_impact: Average revenue impact per incident
-            team_size: Number of engineers
-            
-        Returns:
-            Comprehensive ROI analysis
-        """
-        logger.info(f"Calculating ROI: incidents={monthly_incidents}, "
-                   f"impact=${avg_impact:,}, team={team_size}")
-        
-        # Base scenario (realistic)
-        base = self._calculate_with_monte_carlo(
-            monthly_incidents, avg_impact, team_size,
-            savings_rate_mean=0.82, savings_rate_std=0.05,
-            efficiency_mean=0.85, efficiency_std=0.03
-        )
-        
-        # Best case (aggressive adoption)
-        best = self._calculate_with_monte_carlo(
-            monthly_incidents, avg_impact, team_size,
-            savings_rate_mean=0.92, savings_rate_std=0.03,
-            efficiency_mean=0.92, efficiency_std=0.02
-        )
-        
-        # Worst case (conservative)
-        worst = self._calculate_with_monte_carlo(
-            monthly_incidents, avg_impact, team_size,
-            savings_rate_mean=0.72, savings_rate_std=0.07,
-            efficiency_mean=0.78, efficiency_std=0.05
-        )
-        
-        # Generate recommendation
-        recommendation = self._get_recommendation(base.mean_roi)
-        
-        # Calculate industry comparison
-        comparison = self._get_industry_comparison(base.mean_roi)
-        
-        return {
-            "summary": {
-                "your_annual_impact": f"${base.mean_annual_impact:,.0f}",
-                "potential_savings": f"${base.mean_savings:,.0f}",
-                "enterprise_cost": f"${base.enterprise_cost:,.0f}",
-                "roi_multiplier": f"{base.mean_roi:.1f}×",
-                "payback_months": f"{base.mean_payback:.1f}",
-                "annual_roi_percentage": f"{base.mean_roi_percentage:.0f}%",
-                "monte_carlo_simulations": 1000,
-                "confidence_interval": f"{base.roi_ci[0]:.1f}× - {base.roi_ci[1]:.1f}×"
-            },
-            "scenarios": {
-                "base_case": {
-                    "roi": f"{base.mean_roi:.1f}×",
-                    "payback": f"{base.mean_payback:.1f} months",
-                    "confidence": base.confidence.value,
-                    "ci_low": f"{base.roi_ci[0]:.1f}×",
-                    "ci_high": f"{base.roi_ci[1]:.1f}×"
-                },
-                "best_case": {
-                    "roi": f"{best.mean_roi:.1f}×",
-                    "payback": f"{best.mean_payback:.1f} months",
-                    "confidence": best.confidence.value,
-                    "ci_low": f"{best.roi_ci[0]:.1f}×",
-                    "ci_high": f"{best.roi_ci[1]:.1f}×"
-                },
-                "worst_case": {
-                    "roi": f"{worst.mean_roi:.1f}×",
-                    "payback": f"{worst.mean_payback:.1f} months",
-                    "confidence": worst.confidence.value,
-                    "ci_low": f"{worst.roi_ci[0]:.1f}×",
-                    "ci_high": f"{worst.roi_ci[1]:.1f}×"
-                }
-            },
-            "comparison": comparison,
-            "recommendation": recommendation,
-            "monte_carlo_stats": {
-                "base_roi_std": f"{base.roi_std:.2f}",
-                "best_roi_std": f"{best.roi_std:.2f}",
-                "worst_roi_std": f"{worst.roi_std:.2f}"
-            }
-        }
-    
-    def _calculate_with_monte_carlo(self, monthly_incidents: int, avg_impact: float,
-                                   team_size: int, savings_rate_mean: float,
-                                   savings_rate_std: float, efficiency_mean: float,
-                                   efficiency_std: float) -> 'MonteCarloResult':
-        """
-        Run Monte Carlo simulation for ROI calculation
-        
-        Returns:
-            MonteCarloResult with statistics
-        """
-        np.random.seed(42)  # For reproducible results
-        
-        n_simulations = 1000
-        
-        # Generate random samples with normal distribution
-        savings_rates = np.random.normal(
-            savings_rate_mean, savings_rate_std, n_simulations
-        )
-        efficiencies = np.random.normal(
-            efficiency_mean, efficiency_std, n_simulations
-        )
-        
-        # Clip to reasonable bounds
-        savings_rates = np.clip(savings_rates, 0.5, 0.95)
-        efficiencies = np.clip(efficiencies, 0.5, 0.95)
-        
-        # Calculate for each simulation
-        annual_impacts = monthly_incidents * 12 * avg_impact
-        enterprise_costs = team_size * self.engineer_annual_cost
-        
-        savings_list = []
-        roi_list = []
-        roi_percentage_list = []
-        payback_list = []
-        
-        for i in range(n_simulations):
-            savings = annual_impacts * savings_rates[i] * efficiencies[i]
-            roi = savings / enterprise_costs if enterprise_costs > 0 else 0
-            roi_percentage = (roi - 1) * 100
-            payback = (enterprise_costs / (savings / 12)) if savings > 0 else 0
-            
-            savings_list.append(savings)
-            roi_list.append(roi)
-            roi_percentage_list.append(roi_percentage)
-            payback_list.append(payback)
-        
-        # Convert to numpy arrays for statistics
-        savings_arr = np.array(savings_list)
-        roi_arr = np.array(roi_list)
-        roi_percentage_arr = np.array(roi_percentage_list)
-        payback_arr = np.array(payback_list)
-        
-        # Calculate statistics
-        mean_savings = np.mean(savings_arr)
-        mean_roi = np.mean(roi_arr)
-        mean_roi_percentage = np.mean(roi_percentage_arr)
-        mean_payback = np.mean(payback_arr)
-        
-        roi_std = np.std(roi_arr)
-        roi_ci = (
-            np.percentile(roi_arr, 25),
-            np.percentile(roi_arr, 75)
-        )
-        
-        # Determine confidence level
-        if roi_std / mean_roi < 0.1:  # Low relative standard deviation
-            confidence = ROIConfidence.HIGH
-        elif roi_std / mean_roi < 0.2:
-            confidence = ROIConfidence.MEDIUM
-        else:
-            confidence = ROIConfidence.LOW
-        
-        return MonteCarloResult(
-            mean_annual_impact=annual_impacts,
-            enterprise_cost=enterprise_costs,
-            mean_savings=mean_savings,
-            mean_roi=mean_roi,
-            mean_roi_percentage=mean_roi_percentage,
-            mean_payback=mean_payback,
-            roi_std=roi_std,
-            roi_ci=roi_ci,
-            confidence=confidence,
-            n_simulations=n_simulations
-        )
-    
-    def _get_recommendation(self, roi_multiplier: float) -> Dict[str, str]:
-        """Get recommendation based on ROI"""
-        if roi_multiplier >= 5.0:
-            return {
-                "action": "🚀 Deploy ARF Enterprise",
-                "reason": "Exceptional ROI (>5×) with quick payback",
-                "timeline": "30-day implementation",
-                "expected_value": ">$1M annual savings",
-                "priority": "High",
-                "next_steps": [
-                    "Schedule enterprise demo",
-                    "Request custom ROI analysis",
-                    "Start 30-day trial"
-                ]
-            }
-        elif roi_multiplier >= 3.0:
-            return {
-                "action": "✅ Implement ARF Enterprise",
-                "reason": "Strong ROI (3-5×) with operational benefits",
-                "timeline": "60-day phased rollout",
-                "expected_value": ">$500K annual savings",
-                "priority": "Medium",
-                "next_steps": [
-                    "Evaluate OSS edition",
-                    "Run pilot with 2-3 services",
-                    "Measure initial impact"
-                ]
-            }
-        elif roi_multiplier >= 2.0:
-            return {
-                "action": "📊 Evaluate ARF Enterprise",
-                "reason": "Positive ROI (2-3×) with learning benefits",
-                "timeline": "90-day evaluation",
-                "expected_value": ">$250K annual savings",
-                "priority": "Medium-Low",
-                "next_steps": [
-                    "Start with OSS edition",
-                    "Document baseline metrics",
-                    "Identify pilot use cases"
-                ]
-            }
-        else:
-            return {
-                "action": "🆓 Start with ARF OSS",
-                "reason": "Validate value before Enterprise investment",
-                "timeline": "14-day evaluation",
-                "expected_value": "Operational insights + clear upgrade path",
-                "priority": "Low",
-                "next_steps": [
-                    "Install OSS edition",
-                    "Analyze 2-3 incident scenarios",
-                    "Document potential improvements"
-                ]
-            }
-    
-    def _get_percentile(self, roi_multiplier: float) -> int:
-        """Calculate percentile vs industry benchmarks"""
-        benchmarks = [
-            (10.0, 5),   # Top 5% at 10× ROI
-            (8.0, 10),   # Top 10% at 8× ROI
-            (5.0, 25),   # Top 25% at 5× ROI
-            (3.0, 50),   # Top 50% at 3× ROI
-            (2.0, 75),   # Top 75% at 2× ROI
-            (1.0, 90)    # Top 90% at 1× ROI
-        ]
-        
-        for threshold, percentile in benchmarks:
-            if roi_multiplier >= threshold:
-                return percentile
-        
-        return 95  # Bottom 5%
-    
-    def _get_industry_comparison(self, roi_multiplier: float) -> Dict[str, str]:
-        """Get industry comparison metrics"""
-        percentile = self._get_percentile(roi_multiplier)
-        
-        return {
-            "industry_average": "5.2× ROI",
-            "top_performers": "8.7× ROI",
-            "your_position": f"Top {percentile}%",
-            "benchmark_analysis": "Above industry average" if roi_multiplier >= 5.2 else "Below industry average",
-            "improvement_potential": f"{max(0, 8.7 - roi_multiplier):.1f}× additional ROI possible"
-        }
-    
-    def calculate_simple_roi(self, monthly_incidents: int, 
-                            avg_impact: float, team_size: int) -> Dict[str, Any]:
-        """
-        Simple ROI calculation without Monte Carlo
-        
-        For backward compatibility
-        """
-        result = self._calculate_with_monte_carlo(
-            monthly_incidents, avg_impact, team_size,
-            savings_rate_mean=self.default_savings_rate,
-            savings_rate_std=0.05,
-            efficiency_mean=0.85,
-            efficiency_std=0.03
-        )
-        
-        return {
-            "annual_impact": result.mean_annual_impact,
-            "enterprise_cost": result.enterprise_cost,
-            "savings": result.mean_savings,
-            "roi_multiplier": result.mean_roi,
-            "roi_percentage": result.mean_roi_percentage,
-            "payback_months": result.mean_payback
-        }
-
-
-@dataclass
-class MonteCarloResult:
-    """Result of Monte Carlo simulation"""
-    mean_annual_impact: float
-    enterprise_cost: float
-    mean_savings: float
-    mean_roi: float
-    mean_roi_percentage: float
-    mean_payback: float
-    roi_std: float
-    roi_ci: Tuple[float, float]
-    confidence: ROIConfidence
-    n_simulations: int

core/data_models.py

@@ -1,344 +0,0 @@
-"""
-Pythonic data models for ARF Demo - COMPLETE VERSION
-"""
-
-from dataclasses import dataclass, asdict
-from enum import Enum
-from typing import Dict, List, Optional, Any
-import datetime
-
-# Import from actual ARF OSS package
-try:
-    from agentic_reliability_framework.arf_core.models.healing_intent import (
-        HealingIntent,
-        create_scale_out_intent,
-        create_rollback_intent,
-        create_restart_intent
-    )
-    from agentic_reliability_framework.arf_core.engine.simple_mcp_client import OSSMCPClient
-    ARF_OSS_AVAILABLE = True
-except ImportError:
-    ARF_OSS_AVAILABLE = False
-    # Fallback mock classes for demo
-    class HealingIntent:
-        def __init__(self, **kwargs):
-            self.intent_type = kwargs.get("intent_type", "scale_out")
-            self.parameters = kwargs.get("parameters", {})
-        
-        def to_dict(self):
-            return {
-                "intent_type": self.intent_type,
-                "parameters": self.parameters,
-                "created_at": datetime.datetime.now().isoformat()
-            }
-    
-    def create_scale_out_intent(resource_type: str, scale_factor: float = 2.0):
-        return HealingIntent(
-            intent_type="scale_out",
-            parameters={
-                "resource_type": resource_type,
-                "scale_factor": scale_factor,
-                "action": "Increase capacity"
-            }
-        )
-    
-    class OSSMCPClient:
-        def __init__(self):
-            self.mode = "advisory"
-        
-        def analyze_incident(self, metrics: Dict, pattern: str = "") -> Dict:
-            return {
-                "status": "analysis_complete",
-                "recommendations": [
-                    "Increase resource allocation",
-                    "Implement monitoring",
-                    "Add circuit breakers",
-                    "Optimize configuration"
-                ],
-                "confidence": 0.92,
-                "pattern_matched": pattern,
-                "healing_intent": {
-                    "type": "scale_out",
-                    "requires_execution": True
-                }
-            }
-
-class IncidentSeverity(Enum):
-    """Enum for incident severity levels"""
-    LOW = "LOW"
-    MEDIUM = "MEDIUM" 
-    HIGH = "HIGH"
-    CRITICAL = "CRITICAL"
-
-class DemoMode(Enum):
-    """Enum for demo modes"""
-    QUICK = "quick"
-    COMPREHENSIVE = "comprehensive"
-    INVESTOR = "investor"
-
-@dataclass
-class OSSAnalysis:
-    """Structured OSS analysis results - using actual ARF"""
-    status: str
-    recommendations: List[str]
-    estimated_time: str
-    engineers_needed: str
-    manual_effort: str
-    confidence_score: float = 0.95
-    healing_intent: Optional[Dict] = None
-    
-    def to_dict(self) -> Dict:
-        """Convert to dictionary, including healing intent if available"""
-        data = asdict(self)
-        if self.healing_intent:
-            data["healing_intent"] = {
-                "type": "HealingIntent",
-                "recommendations": self.recommendations,
-                "requires_execution": True
-            }
-        return data
-    
-    @classmethod
-    def from_arf_analysis(cls, arf_result: Dict, scenario_name: str) -> 'OSSAnalysis':
-        """Create from actual ARF analysis result"""
-        recommendations = arf_result.get("recommendations", [
-            "Increase resource allocation",
-            "Implement monitoring",
-            "Add circuit breakers",
-            "Optimize configuration"
-        ])
-        
-        return cls(
-            status="✅ ARF OSS Analysis Complete",
-            recommendations=recommendations,
-            estimated_time="45-90 minutes",
-            engineers_needed="2-3 engineers",
-            manual_effort="High",
-            confidence_score=0.92,
-            healing_intent={
-                "scenario": scenario_name,
-                "actions": recommendations,
-                "execution_required": True,
-                "auto_execution": False  # OSS is advisory only
-            }
-        )
-
-@dataclass
-class EnterpriseResults:
-    """Structured enterprise execution results"""
-    actions_completed: List[str]
-    metrics_improvement: Dict[str, str]
-    business_impact: Dict[str, Any]
-    approval_required: bool = True
-    execution_time: str = ""
-    healing_intent_executed: bool = True
-    
-    def to_dict(self) -> Dict:
-        data = asdict(self)
-        data["arf_enterprise"] = {
-            "execution_complete": True,
-            "learning_applied": True,
-            "audit_trail_created": True
-        }
-        return data
-
-@dataclass
-class IncidentScenario:
-    """Pythonic incident scenario model with ARF integration"""
-    name: str
-    severity: IncidentSeverity
-    metrics: Dict[str, str]
-    impact: Dict[str, str]
-    arf_pattern: str = ""  # ARF pattern name for RAG recall
-    oss_analysis: Optional[OSSAnalysis] = None
-    enterprise_results: Optional[EnterpriseResults] = None
-    
-    def to_dict(self) -> Dict:
-        """Convert to dictionary for JSON serialization"""
-        data = {
-            "name": self.name,
-            "severity": self.severity.value,
-            "metrics": self.metrics,
-            "impact": self.impact,
-            "arf_oss_available": ARF_OSS_AVAILABLE
-        }
-        if self.oss_analysis:
-            data["oss_analysis"] = self.oss_analysis.to_dict()
-        if self.enterprise_results:
-            data["enterprise_results"] = self.enterprise_results.to_dict()
-        return data
-
-@dataclass
-class DemoStep:
-    """Demo step for presenter guidance"""
-    title: str
-    scenario: Optional[str]
-    action: str
-    message: str
-    icon: str = "🎯"
-    arf_integration: bool = False
-
-# ===========================================
-# INCIDENT DATABASE - ADD THIS CLASS
-# ===========================================
-
-class IncidentDatabase:
-    """Database of incident scenarios for the demo"""
-    
-    @staticmethod
-    def get_scenarios() -> Dict[str, IncidentScenario]:
-        """Get all incident scenarios"""
-        cache_miss = IncidentScenario(
-            name="Cache Miss Storm",
-            severity=IncidentSeverity.CRITICAL,
-            metrics={
-                "Cache Hit Rate": "18.5% (Critical)",
-                "Database Load": "92% (Overloaded)",
-                "Response Time": "1850ms (Slow)",
-                "Affected Users": "45,000",
-                "Eviction Rate": "125/sec"
-            },
-            impact={
-                "Revenue Loss": "$8,500/hour",
-                "Page Load Time": "+300%",
-                "Users Impacted": "45,000",
-                "SLA Violation": "Yes",
-                "Customer Satisfaction": "-40%"
-            },
-            arf_pattern="cache_miss_storm",
-            oss_analysis=OSSAnalysis(
-                status="✅ Analysis Complete",
-                recommendations=[
-                    "Increase Redis cache memory allocation by 2x",
-                    "Implement cache warming strategy with predictive loading",
-                    "Optimize key patterns and implement TTL adjustments",
-                    "Add circuit breaker for graceful database fallback",
-                    "Deploy monitoring for cache hit rate trends"
-                ],
-                estimated_time="60-90 minutes",
-                engineers_needed="2-3 SREs + 1 DBA",
-                manual_effort="High",
-                confidence_score=0.92,
-                healing_intent={
-                    "type": "scale_out",
-                    "resource": "cache",
-                    "scale_factor": 2.0
-                }
-            ),
-            enterprise_results=EnterpriseResults(
-                actions_completed=[
-                    "✅ Auto-scaled Redis cluster: 4GB → 8GB",
-                    "✅ Deployed intelligent cache warming service",
-                    "✅ Optimized 12 key patterns with ML recommendations",
-                    "✅ Implemented circuit breaker with 95% success rate",
-                    "✅ Validated recovery with automated testing"
-                ],
-                metrics_improvement={
-                    "Cache Hit Rate": "18.5% → 72%",
-                    "Response Time": "1850ms → 450ms",
-                    "Database Load": "92% → 45%",
-                    "Throughput": "1250 → 2450 req/sec"
-                },
-                business_impact={
-                    "Recovery Time": "60 min → 12 min",
-                    "Cost Saved": "$7,200",
-                    "Users Impacted": "45,000 → 0",
-                    "Revenue Protected": "$1,700",
-                    "MTTR Improvement": "80% reduction"
-                },
-                approval_required=True,
-                execution_time="8 minutes"
-            )
-        )
-        
-        db_exhaustion = IncidentScenario(
-            name="Database Connection Pool Exhaustion",
-            severity=IncidentSeverity.HIGH,
-            metrics={
-                "Active Connections": "98/100 (Critical)",
-                "API Latency": "2450ms",
-                "Error Rate": "15.2%",
-                "Queue Depth": "1250",
-                "Connection Wait Time": "45s"
-            },
-            impact={
-                "Revenue Loss": "$4,200/hour",
-                "Affected Services": "API Gateway, User Service, Payment Service",
-                "SLA Violation": "Yes",
-                "Partner Impact": "3 external APIs"
-            },
-            arf_pattern="db_connection_exhaustion",
-            oss_analysis=OSSAnalysis(
-                status="✅ Analysis Complete",
-                recommendations=[
-                    "Increase connection pool size from 100 to 200",
-                    "Add connection timeout (30s)",
-                    "Implement leak detection",
-                    "Add connection health checks",
-                    "Optimize query patterns"
-                ],
-                estimated_time="45-60 minutes",
-                engineers_needed="1-2 DBAs",
-                manual_effort="Medium-High",
-                confidence_score=0.88
-            )
-        )
-        
-        memory_leak = IncidentScenario(
-            name="Memory Leak in Production",
-            severity=IncidentSeverity.HIGH,
-            metrics={
-                "Memory Usage": "96% (Critical)",
-                "GC Pause Time": "4500ms",
-                "Error Rate": "28.5%",
-                "Restart Frequency": "12/hour",
-                "Heap Fragmentation": "42%"
-            },
-            impact={
-                "Revenue Loss": "$5,500/hour",
-                "Session Loss": "8,500 users",
-                "Customer Impact": "High",
-                "Support Tickets": "+300%"
-            },
-            arf_pattern="memory_leak_java",
-            oss_analysis=OSSAnalysis(
-                status="✅ Analysis Complete",
-                recommendations=[
-                    "Increase JVM heap size from 4GB to 8GB",
-                    "Implement memory leak detection with profiling",
-                    "Add proactive health checks",
-                    "Schedule rolling restart with zero downtime",
-                    "Deploy memory monitoring dashboard"
-                ],
-                estimated_time="75-90 minutes",
-                engineers_needed="2 Java SREs",
-                manual_effort="High",
-                confidence_score=0.85
-            )
-        )
-        
-        api_rate_limit = IncidentScenario(
-            name="API Rate Limit Exceeded",
-            severity=IncidentSeverity.MEDIUM,
-            metrics={
-                "429 Error Rate": "42.5%",
-                "Successful Requests": "58.3%",
-                "API Latency": "120ms",
-                "Queue Depth": "1250",
-                "Client Satisfaction": "65/100"
-            },
-            impact={
-                "Revenue Loss": "$1,800/hour",
-                "Affected Partners": "8",
-                "Partner SLA Violations": "3",
-                "Business Impact": "Medium"
-            },
-            arf_pattern="api_rate_limit"
-        )
-        
-        return {
-            "Cache Miss Storm": cache_miss,
-            "Database Connection Pool Exhaustion": db_exhaustion,
-            "Memory Leak in Production": memory_leak,
-            "API Rate Limit Exceeded": api_rate_limit
-        }

core/enterprise_simulation.py

@@ -1,376 +0,0 @@
-"""
-Enterprise Feature Simulation - Shows what ARF Enterprise adds on top of OSS
-Not real execution, but demonstrates the value proposition
-"""
-import asyncio
-import logging
-from typing import Dict, Any, List
-from datetime import datetime
-import random
-
-logger = logging.getLogger(__name__)
-
-# Trial license for demo
-DEMO_TRIAL_LICENSE = "ARF-TRIAL-DEMO-2026"
-
-class EnterpriseFeatureSimulation:
-    """
-    Simulates Enterprise features that would be available with arf_enterprise package
-    
-    Shows:
-    1. Novel execution protocols
-    2. Rollback guarantees
-    3. Deterministic confidence
-    4. Autonomous healing
-    5. Enhanced safety features
-    """
-    
-    def __init__(self):
-        self.enterprise_available = False
-        self.trial_license = DEMO_TRIAL_LICENSE
-        self._check_enterprise()
-    
-    def _check_enterprise(self):
-        """Check if enterprise package is available"""
-        try:
-            # Try to import real enterprise package
-            from arf_enterprise import (
-                create_enterprise_server,
-                EnterpriseLLMClient,
-                RollbackController,
-                ExecutionMode,
-                DeterministicConfidence,
-                NovelExecutionIntent,
-                get_novel_execution_capabilities
-            )
-            self.enterprise_available = True
-            logger.info("✅ Real ARF Enterprise package available")
-        except ImportError:
-            self.enterprise_available = False
-            logger.info("⚠️ ARF Enterprise package not available - using simulation")
-    
-    async def enhance_oss_analysis(self, oss_analysis: Dict[str, Any], scenario_name: str) -> Dict[str, Any]:
-        """
-        Enhance OSS analysis with Enterprise features
-        
-        Shows what Enterprise adds:
-        - Novel execution protocols
-        - Rollback guarantees
-        - Deterministic confidence
-        - Business impact analysis
-        """
-        logger.info(f"🏢 Enhancing OSS analysis with Enterprise features for: {scenario_name}")
-        
-        enhancement_start = datetime.now()
-        
-        try:
-            # Extract data from OSS analysis
-            oss_intent = oss_analysis.get("analysis", {}).get("decision", {})
-            similar_incidents = oss_analysis.get("analysis", {}).get("recall", [])
-            detection = oss_analysis.get("analysis", {}).get("detection", {})
-            
-            # 1. Apply deterministic confidence system (Enterprise feature)
-            deterministic_confidence = self._create_deterministic_confidence(
-                detection, similar_incidents, scenario_name
-            )
-            
-            # 2. Apply novel execution protocols (Enterprise feature)
-            novel_execution = self._apply_novel_execution_protocols(
-                oss_intent, deterministic_confidence, scenario_name
-            )
-            
-            # 3. Prepare rollback guarantees (Enterprise feature)
-            rollback_guarantees = await self._prepare_rollback_guarantees(
-                oss_intent, scenario_name
-            )
-            
-            # 4. Calculate enhanced business impact (Enterprise feature)
-            business_impact = self._calculate_enhanced_business_impact(
-                scenario_name, similar_incidents
-            )
-            
-            # 5. Determine execution mode capabilities
-            execution_capabilities = self._get_execution_capabilities()
-            
-            enhancement_time = (datetime.now() - enhancement_start).total_seconds() * 1000
-            
-            return {
-                "enterprise_available": self.enterprise_available,
-                "trial_license": self.trial_license if not self.enterprise_available else "Real License",
-                "enhancements": {
-                    "deterministic_confidence": deterministic_confidence,
-                    "novel_execution_protocols": novel_execution,
-                    "rollback_guarantees": rollback_guarantees,
-                    "business_impact_analysis": business_impact,
-                    "execution_capabilities": execution_capabilities
-                },
-                "value_proposition": [
-                    "✅ Autonomous execution with safety guarantees",
-                    "✅ Novel execution protocols for unprecedented incidents",
-                    "✅ Deterministic confidence scoring (not just ML probabilities)",
-                    "✅ Rollback guarantees for zero-downtime deployments",
-                    "✅ Business-aware impact analysis",
-                    "✅ Audit trail and compliance reporting",
-                    f"✅ Execution modes: {', '.join(execution_capabilities['modes'])}"
-                ],
-                "processing_time_ms": enhancement_time,
-                "requires_real_enterprise": not self.enterprise_available,
-                "upgrade_cta": "Contact sales@arf.dev for Enterprise trial" if not self.enterprise_available else None
-            }
-            
-        except Exception as e:
-            logger.error(f"Enterprise enhancement failed: {e}")
-            return {
-                "enterprise_available": self.enterprise_available,
-                "error": str(e),
-                "fallback_message": "OSS analysis complete. Enterprise features require arf_enterprise package."
-            }
-    
-    def _create_deterministic_confidence(self, detection: Dict, similar_incidents: List, scenario_name: str) -> Dict[str, Any]:
-        """Simulate deterministic confidence system (Enterprise feature)"""
-        detection_confidence = detection.get("confidence", 0.85)
-        
-        # Calculate pattern confidence from similar incidents
-        if similar_incidents:
-            pattern_confidence = sum([inc.get("similarity_score", 0.7) for inc in similar_incidents]) / len(similar_incidents)
-            success_rate = sum([1 for inc in similar_incidents if inc.get("success", False)]) / len(similar_incidents)
-        else:
-            pattern_confidence = 0.75
-            success_rate = 0.70
-        
-        # Scenario-specific adjustments
-        scenario_factors = {
-            "Cache Miss Storm": {"historical_pattern": 0.92, "current_metrics": 0.87, "system_state": 0.95},
-            "Database Connection Pool Exhaustion": {"historical_pattern": 0.88, "current_metrics": 0.82, "system_state": 0.90},
-            "Kubernetes Memory Leak": {"historical_pattern": 0.90, "current_metrics": 0.85, "system_state": 0.92},
-            "API Rate Limit Storm": {"historical_pattern": 0.85, "current_metrics": 0.88, "system_state": 0.87},
-            "Network Partition": {"historical_pattern": 0.93, "current_metrics": 0.90, "system_state": 0.96},
-            "Storage I/O Saturation": {"historical_pattern": 0.87, "current_metrics": 0.83, "system_state": 0.89}
-        }
-        
-        factors = scenario_factors.get(scenario_name, {"historical_pattern": 0.85, "current_metrics": 0.80, "system_state": 0.85})
-        
-        # Combine factors deterministically (not just ML probability)
-        business_context = 0.88  # Always consider business impact
-        safety_margin = 0.95  # Enterprise includes safety margins
-        
-        components = [
-            {"component": "historical_pattern", "value": factors["historical_pattern"], "weight": 0.25},
-            {"component": "current_metrics", "value": factors["current_metrics"], "weight": 0.25},
-            {"component": "system_state", "value": factors["system_state"], "weight": 0.20},
-            {"component": "detection_confidence", "value": detection_confidence, "weight": 0.15},
-            {"component": "business_context", "value": business_context, "weight": 0.10},
-            {"component": "safety_margin", "value": safety_margin, "weight": 0.05}
-        ]
-        
-        # Calculate weighted score
-        weighted_score = sum(c["value"] * c["weight"] for c in components)
-        
-        return {
-            "score": round(weighted_score, 3),
-            "components": components,
-            "deterministic": True,  # Enterprise feature: deterministic not probabilistic
-            "explainable": True,  # Enterprise feature: each component explained
-            "safety_margin_included": True
-        }
-    
-    def _apply_novel_execution_protocols(self, oss_intent: Dict, confidence: Dict, scenario_name: str) -> Dict[str, Any]:
-        """Apply novel execution protocols (Enterprise feature)"""
-        # Determine novelty level based on confidence and scenario
-        confidence_score = confidence.get("score", 0.85)
-        
-        if confidence_score >= 0.95:
-            novelty_level = "KNOWN_PATTERN"
-            risk_category = "LOW"
-            execution_approach = "autonomous_safe"
-        elif confidence_score >= 0.85:
-            novelty_level = "PARTIAL_MATCH"
-            risk_category = "MEDIUM"
-            execution_approach = "human_approval_required"
-        else:
-            novelty_level = "NOVEL_SCENARIO"
-            risk_category = "HIGH"
-            execution_approach = "enhanced_monitoring_first"
-        
-        return {
-            "novelty_level": novelty_level,
-            "risk_category": risk_category,
-            "execution_approach": execution_approach,
-            "protocols_applied": [
-                "deterministic_confidence_validation",
-                "blast_radius_containment",
-                "business_hour_compliance",
-                "rollback_preparation",
-                "circuit_breaker_setup"
-            ],
-            "enterprise_feature": True,
-            "requires_license": True
-        }
-    
-    async def _prepare_rollback_guarantees(self, oss_intent: Dict, scenario_name: str) -> Dict[str, Any]:
-        """Prepare rollback guarantees (Enterprise feature)"""
-        await asyncio.sleep(0.1)  # Simulate rollback preparation
-        
-        component = oss_intent.get("component", "unknown")
-        
-        return {
-            "rollback_prepared": True,
-            "state_id": f"state_{datetime.now().timestamp()}",
-            "guarantee": "STRONG",
-            "recovery_time_estimate": "45 seconds",
-            "snapshot_strategy": "incremental",
-            "verification_complete": True,
-            "rollback_scenarios": [
-                f"Restore {component} to previous state",
-                "Rollback configuration changes",
-                "Restore database connections",
-                "Reset circuit breakers"
-            ],
-            "enterprise_feature": True,
-            "requires_enterprise_server": True
-        }
-    
-    def _calculate_enhanced_business_impact(self, scenario_name: str, similar_incidents: List) -> Dict[str, Any]:
-        """Calculate enhanced business impact (Enterprise feature)"""
-        # Get average savings from similar incidents
-        if similar_incidents:
-            avg_savings = sum(inc.get("cost_savings", 5000) for inc in similar_incidents) / len(similar_incidents)
-            avg_resolution_time = 15  # minutes (average from similar incidents)
-        else:
-            avg_savings = 6500
-            avg_resolution_time = 20
-        
-        # Scenario-specific impacts
-        scenario_impacts = {
-            "Cache Miss Storm": {
-                "users_affected": 45000,
-                "revenue_risk_per_hour": 8500,
-                "recovery_time_manual": 45,
-                "recovery_time_arf": 12
-            },
-            "Database Connection Pool Exhaustion": {
-                "users_affected": 25000,
-                "revenue_risk_per_hour": 4200,
-                "recovery_time_manual": 35,
-                "recovery_time_arf": 15
-            },
-            "Kubernetes Memory Leak": {
-                "users_affected": 35000,
-                "revenue_risk_per_hour": 5500,
-                "recovery_time_manual": 40,
-                "recovery_time_arf": 18
-            },
-            "API Rate Limit Storm": {
-                "users_affected": 20000,
-                "revenue_risk_per_hour": 3800,
-                "recovery_time_manual": 25,
-                "recovery_time_arf": 8
-            },
-            "Network Partition": {
-                "users_affected": 75000,
-                "revenue_risk_per_hour": 12000,
-                "recovery_time_manual": 60,
-                "recovery_time_arf": 20
-            },
-            "Storage I/O Saturation": {
-                "users_affected": 30000,
-                "revenue_risk_per_hour": 6800,
-                "recovery_time_manual": 50,
-                "recovery_time_arf": 22
-            }
-        }
-        
-        impact = scenario_impacts.get(scenario_name, {
-            "users_affected": 30000,
-            "revenue_risk_per_hour": 5000,
-            "recovery_time_manual": 30,
-            "recovery_time_arf": 15
-        })
-        
-        # Calculate ARF benefits
-        time_saved = impact["recovery_time_manual"] - impact["recovery_time_arf"]
-        cost_saved_per_incident = (impact["revenue_risk_per_hour"] / 60) * time_saved
-        
-        return {
-            "scenario_specific": True,
-            "users_protected": impact["users_affected"],
-            "revenue_risk_per_hour": f"${impact['revenue_risk_per_hour']:,}",
-            "recovery_times": {
-                "manual": f"{impact['recovery_time_manual']} minutes",
-                "arf": f"{impact['recovery_time_arf']} minutes",
-                "time_saved": f"{time_saved} minutes",
-                "percent_faster": f"{int((time_saved / impact['recovery_time_manual']) * 100)}%"
-            },
-            "cost_analysis": {
-                "cost_saved_per_incident": f"${int(cost_saved_per_incident):,}",
-                "estimated_annual_savings": f"${int(cost_saved_per_incident * 15 * 12):,}",  # 15 incidents/month
-                "roi_multiplier": "5.2×",
-                "payback_months": "6.0"
-            },
-            "enterprise_feature": True,
-            "business_aware": True
-        }
-    
-    def _get_execution_capabilities(self) -> Dict[str, Any]:
-        """Get execution mode capabilities (Enterprise feature)"""
-        return {
-            "modes": ["advisory", "approval", "autonomous"],
-            "current_mode": "autonomous" if self.enterprise_available else "advisory",
-            "requires_enterprise": ["approval", "autonomous"],
-            "safety_guarantees": {
-                "rollback": "guaranteed" if self.enterprise_available else "not_available",
-                "circuit_breaker": "enabled" if self.enterprise_available else "disabled",
-                "blast_radius": "enforced" if self.enterprise_available else "advisory_only",
-                "business_hours": "enforced" if self.enterprise_available else "monitored"
-            }
-        }
-    
-    async def simulate_execution(self, scenario_name: str, mode: str = "autonomous") -> Dict[str, Any]:
-        """Simulate Enterprise execution"""
-        if mode == "advisory":
-            return {
-                "status": "advisory_only",
-                "message": "OSS mode: Execution not allowed. Upgrade to Enterprise for autonomous healing.",
-                "requires_enterprise": True,
-                "execution_mode": "advisory"
-            }
-        
-        await asyncio.sleep(0.3)
-        
-        if mode == "approval":
-            return {
-                "status": "awaiting_approval",
-                "message": "Enterprise Approval Mode: Healing intent created, awaiting human approval",
-                "requires_human_approval": True,
-                "estimated_savings": "$8,500",
-                "rollback_prepared": True,
-                "execution_mode": "approval"
-            }
-        else:  # autonomous
-            return {
-                "status": "executed",
-                "message": "Enterprise Autonomous Mode: Healing action executed with safety guarantees",
-                "execution_time": "12 minutes",
-                "cost_saved": "$8,500",
-                "rollback_available": True,
-                "rollback_guarantee": "STRONG",
-                "novel_execution_used": True,
-                "execution_mode": "autonomous",
-                "enterprise_features_used": [
-                    "deterministic_confidence",
-                    "novel_execution_protocols",
-                    "rollback_guarantees",
-                    "business_aware_execution"
-                ]
-            }
-
-
-# Factory function
-_enterprise_sim_instance = None
-
-async def get_enterprise_simulation() -> EnterpriseFeatureSimulation:
-    """Get singleton EnterpriseFeatureSimulation instance"""
-    global _enterprise_sim_instance
-    if _enterprise_sim_instance is None:
-        _enterprise_sim_instance = EnterpriseFeatureSimulation()
-    return _enterprise_sim_instance

core/true_arf_orchestrator.py

@@ -1,284 +0,0 @@
-"""
-Updated orchestrator that combines:
-1. True ARF OSS v3.3.9 for real advisory analysis
-2. Enterprise simulation to show value proposition
-"""
-import logging
-import time
-from typing import Dict, Any
-from datetime import datetime, timedelta
-
-logger = logging.getLogger(__name__)
-
-class TrueARFOrchestrator:
-    """
-    True ARF v3.3.9 orchestrator with:
-    - Real OSS package for advisory analysis
-    - Enterprise simulation to show upgrade value
-    """
-    
-    def __init__(self):
-        self.true_oss = None
-        self.enterprise_sim = None
-        self.arf_analysis_results = {}  # Store analysis results for execution
-        self.audit_trail_manager = None  # Will be set by app
-        self._initialize_components()
-    
-    def _initialize_components(self):
-        """Initialize true ARF components"""
-        try:
-            from core.true_arf_oss import get_true_arf_oss
-            self.true_oss = get_true_arf_oss
-            logger.info("✅ True ARF OSS v3.3.9 component available")
-        except ImportError as e:
-            logger.warning(f"True ARF OSS not available: {e}")
-            self.true_oss = None
-        except Exception as e:
-            logger.error(f"Error initializing True ARF OSS: {e}")
-            self.true_oss = None
-        
-        try:
-            from core.enterprise_simulation import get_enterprise_simulation
-            self.enterprise_sim = get_enterprise_simulation
-            logger.info("✅ Enterprise simulation component available")
-        except ImportError as e:
-            logger.warning(f"Enterprise simulation not available: {e}")
-            self.enterprise_sim = None
-        except Exception as e:
-            logger.error(f"Error initializing Enterprise simulation: {e}")
-            self.enterprise_sim = None
-    
-    async def analyze_incident(self, scenario_name: str, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Complete analysis using:
-        1. True ARF OSS v3.3.9 for real advisory analysis
-        2. Enterprise simulation to show upgrade value
-        """
-        logger.info(f"Running true ARF v3.3.9 analysis for: {scenario_name}")
-        
-        try:
-            # Step 1: Run true OSS analysis
-            oss_analysis = None
-            if self.true_oss:
-                try:
-                    true_oss_instance = await self.true_oss()
-                    if hasattr(true_oss_instance, 'oss_available') and true_oss_instance.oss_available:
-                        oss_analysis = await true_oss_instance.analyze_scenario(scenario_name, scenario_data)
-                    else:
-                        logger.warning("True ARF OSS not available - using fallback mock")
-                        oss_analysis = await self._fallback_oss_analysis(scenario_name, scenario_data)
-                except Exception as e:
-                    logger.error(f"Error in true OSS analysis: {e}")
-                    oss_analysis = await self._fallback_oss_analysis(scenario_name, scenario_data)
-            else:
-                # Fallback to mock
-                oss_analysis = await self._fallback_oss_analysis(scenario_name, scenario_data)
-            
-            # Step 2: Enhance with Enterprise features (simulation)
-            enterprise_enhancements = None
-            if self.enterprise_sim and oss_analysis and oss_analysis.get("status") == "success":
-                try:
-                    enterprise_instance = await self.enterprise_sim()
-                    enterprise_enhancements = await enterprise_instance.enhance_oss_analysis(
-                        oss_analysis, scenario_name
-                    )
-                except Exception as e:
-                    logger.error(f"Error in enterprise enhancement: {e}")
-                    # Continue without enterprise enhancements
-            
-            # Store analysis result for potential execution
-            self.arf_analysis_results[scenario_name] = {
-                "oss_analysis": oss_analysis,
-                "enterprise_enhancements": enterprise_enhancements,
-                "timestamp": datetime.now().isoformat()
-            }
-            
-            # Combine results
-            result = {
-                "status": "success",
-                "scenario": scenario_name,
-                "arf_version": "3.3.9",
-                "true_oss_used": self.true_oss is not None,
-                "enterprise_simulated": self.enterprise_sim is not None,
-                "oss_analysis": oss_analysis,
-                "enterprise_enhancements": enterprise_enhancements,
-                "recommendation": self._get_recommendation(oss_analysis, enterprise_enhancements)
-            }
-            
-            return result
-            
-        except Exception as e:
-            logger.error(f"Analysis failed: {e}", exc_info=True)
-            return {
-                "status": "error",
-                "error": f"Analysis failed: {str(e)}",  # Make sure error is a string
-                "scenario": scenario_name,
-                "suggestion": "Check logs for details"
-            }
-    
-    async def execute_healing(self, scenario_name: str, mode: str = "autonomous") -> Dict[str, Any]:
-        """
-        Execute enterprise healing for a given scenario.
-        
-        Args:
-            scenario_name: Name of the scenario to heal
-            mode: Execution mode ("autonomous", "approval", "manual")
-            
-        Returns:
-            Dict with execution results
-        """
-        try:
-            # Log execution start
-            logger.info(f"⚡ Executing enterprise healing for: {scenario_name} (mode: {mode})")
-            
-            # Get the latest analysis for this scenario
-            if not self.arf_analysis_results or scenario_name not in self.arf_analysis_results:
-                # Run analysis first if not available
-                logger.warning(f"No analysis found for {scenario_name}, running analysis first")
-                await self.analyze_incident(scenario_name, {})
-            
-            # Get the analysis result
-            analysis_result = self.arf_analysis_results.get(scenario_name, {})
-            oss_analysis = analysis_result.get("oss_analysis", {})
-            
-            # Extract healing intent from analysis
-            healing_intent = {}
-            if oss_analysis and "analysis" in oss_analysis and "decision" in oss_analysis["analysis"]:
-                healing_intent = oss_analysis["analysis"]["decision"]
-            elif oss_analysis and "healing_intent" in oss_analysis:
-                healing_intent = oss_analysis["healing_intent"]
-            
-            # Simulate enterprise execution with proper boundaries
-            enterprise_result = {
-                "status": "success",
-                "mode": mode,
-                "scenario": scenario_name,
-                "execution_id": f"exe_{int(time.time())}_{scenario_name.lower().replace(' ', '_')}",
-                "timestamp": datetime.now().isoformat(),
-                "boundary": "Enterprise Simulation",
-                "enterprise_features_used": [
-                    "AutonomousExecutionEngine",
-                    "SafetyOrchestrator",
-                    "ComplianceGuardrails",
-                    "RealTimeTelemetry",
-                    "LearningEngineIntegration"
-                ],
-                "execution_summary": {
-                    "action": healing_intent.get("action", "Scale infrastructure"),
-                    "target": healing_intent.get("target", "redis_cache"),
-                    "parameters": healing_intent.get("parameters", {}),
-                    "confidence": oss_analysis.get("analysis", {}).get("decision", {}).get("confidence", 0.85) 
-                                if oss_analysis else 0.85,
-                    "estimated_duration": "12 minutes",
-                    "blast_radius": "2 services",
-                    "safety_checks_passed": True
-                },
-                "business_impact": {
-                    "mttr_reduction": "73% faster (45m → 12m)",
-                    "cost_saved": 6375,
-                    "revenue_protected": 8500,
-                    "users_protected": 45000,
-                    "incidents_prevented": 3
-                },
-                "telemetry": {
-                    "start_time": datetime.now().isoformat(),
-                    "end_time": (datetime.now() + timedelta(minutes=12)).isoformat(),
-                    "resources_affected": ["redis_node_1", "redis_node_2"],
-                    "rollback_available": True,
-                    "audit_trail_enabled": True
-                },
-                "notes": [
-                    "✅ Enterprise execution simulation complete",
-                    "🔒 Safety boundaries enforced via MCP",
-                    "📊 Real-time telemetry active",
-                    "🧠 Learning engine updated with outcome",
-                    "💾 Audit trail recorded"
-                ]
-            }
-            
-            # Record execution in audit trail if manager is available
-            if self.audit_trail_manager:
-                try:
-                    self.audit_trail_manager.record_execution(
-                        execution_id=enterprise_result["execution_id"],
-                        scenario_name=scenario_name,
-                        status="success",
-                        mode=mode,
-                        details=enterprise_result
-                    )
-                except Exception as e:
-                    logger.warning(f"Could not record execution in audit trail: {e}")
-            
-            logger.info(f"✅ Enterprise healing execution simulated for {scenario_name}")
-            return enterprise_result
-            
-        except Exception as e:
-            logger.error(f"❌ Enterprise healing execution failed: {e}")
-            return {
-                "status": "failed",
-                "error": str(e),
-                "scenario": scenario_name,
-                "mode": mode,
-                "timestamp": datetime.now().isoformat(),
-                "boundary": "Enterprise Simulation Failed",
-                "notes": ["Execution failed in simulation mode"]
-            }
-    
-    async def _fallback_oss_analysis(self, scenario_name: str, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Fallback mock analysis"""
-        try:
-            # Use existing mock ARF with scenario-aware metrics
-            from demo.mock_arf import (
-                simulate_arf_analysis,
-                run_rag_similarity_search,
-                calculate_pattern_confidence,
-                create_mock_healing_intent
-            )
-            
-            scenario_data_with_name = scenario_data.copy()
-            scenario_data_with_name["name"] = scenario_name
-            
-            detection = simulate_arf_analysis(scenario_data_with_name)
-            recall = run_rag_similarity_search(scenario_data_with_name)
-            confidence = calculate_pattern_confidence(scenario_data_with_name, recall)
-            decision = create_mock_healing_intent(scenario_data_with_name, recall, confidence)
-            
-            return {
-                "status": "success",
-                "scenario": scenario_name,
-                "analysis": {
-                    "detection": detection,
-                    "recall": recall,
-                    "decision": decision
-                },
-                "capabilities": {
-                    "execution_allowed": False,
-                    "mcp_modes": ["advisory"],
-                    "oss_boundary": "advisory_only"
-                },
-                "note": "Using fallback mock analysis"
-            }
-        except Exception as e:
-            logger.error(f"Fallback analysis failed: {e}")
-            return {
-                "status": "error",
-                "error": f"Fallback analysis failed: {str(e)}",
-                "scenario": scenario_name
-            }
-    
-    def _get_recommendation(self, oss_analysis: Dict, enterprise_enhancements: Dict) -> str:
-        """Generate recommendation based on analysis"""
-        if not oss_analysis or oss_analysis.get("status") != "success":
-            return "Analysis failed. Check logs."
-        
-        if enterprise_enhancements and enterprise_enhancements.get("enterprise_available"):
-            return "✅ Both OSS and Enterprise features available. Full ARF v3.3.9 capabilities enabled."
-        elif enterprise_enhancements:
-            return "✅ OSS analysis complete. ⚡ Enterprise features simulated - shows upgrade value. Contact sales@arf.dev for Enterprise trial."
-        else:
-            return "✅ OSS analysis complete. Install agentic-reliability-framework==3.3.9 for real advisory capabilities."
-    
-    def set_audit_trail_manager(self, manager):
-        """Set audit trail manager for recording executions."""
-        self.audit_trail_manager = manager
-        logger.info("✅ Audit trail manager connected to orchestrator")

core/true_arf_oss.py

@@ -1,695 +0,0 @@
-"""
-True ARF OSS v3.3.9 - Integration with existing OSS MCP Client
-Production-grade multi-agent AI for reliability monitoring (Advisory only)
-This bridges the demo orchestrator with the real ARF OSS implementation.
-"""
-
-import asyncio
-import logging
-import time
-import uuid
-from typing import Dict, Any, List, Optional
-from dataclasses import dataclass, field
-import json
-
-logger = logging.getLogger(__name__)
-
-# ============================================================================
-# TRUE ARF OSS IMPLEMENTATION
-# ============================================================================
-
-class TrueARFOSS:
-    """
-    True ARF OSS v3.3.9 - Complete integration with OSS MCP Client
-    
-    This is the class that TrueARF337Orchestrator expects to import.
-    It provides real ARF OSS functionality by integrating with the
-    existing OSS MCP client and implementing the 3-agent pattern.
-    """
-    
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
-        self.config = config or {}
-        self.oss_available = True
-        self.mcp_client = None
-        self.agent_stats = {
-            "detection_calls": 0,
-            "recall_calls": 0,
-            "decision_calls": 0,
-            "total_analyses": 0,
-            "total_time_ms": 0.0
-        }
-        
-        logger.info("True ARF OSS v3.3.9 initialized")
-    
-    async def _get_mcp_client(self):
-        """Lazy load OSS MCP client"""
-        if self.mcp_client is None:
-            try:
-                # Use the existing OSS MCP client
-                from agentic_reliability_framework.arf_core.engine.oss_mcp_client import (
-                    OSSMCPClient,
-                    create_oss_mcp_client
-                )
-                self.mcp_client = create_oss_mcp_client(self.config)
-                logger.info("✅ OSS MCP Client loaded successfully")
-            except ImportError as e:
-                logger.error(f"❌ Failed to load OSS MCP Client: {e}")
-                raise ImportError("Real ARF OSS package not installed")
-        
-        return self.mcp_client
-    
-    async def analyze_scenario(self, scenario_name: str, 
-                             scenario_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Complete ARF analysis for a scenario using real OSS agents
-        
-        Implements the 3-agent pattern:
-        1. Detection Agent: Analyze metrics for anomalies
-        2. Recall Agent: Find similar historical incidents
-        3. Decision Agent: Generate healing intent with confidence
-        
-        Args:
-            scenario_name: Name of the scenario
-            scenario_data: Scenario data including metrics and context
-            
-        Returns:
-            Complete analysis result with real ARF data
-        """
-        start_time = time.time()
-        self.agent_stats["total_analyses"] += 1
-        
-        try:
-            logger.info(f"True ARF OSS: Starting analysis for {scenario_name}")
-            
-            # Get OSS MCP client
-            mcp_client = await self._get_mcp_client()
-            
-            # Extract component and metrics from scenario
-            component = scenario_data.get("component", "unknown")
-            metrics = scenario_data.get("metrics", {})
-            business_impact = scenario_data.get("business_impact", {})
-            
-            # Convert scenario to telemetry format
-            telemetry = self._scenario_to_telemetry(scenario_name, component, metrics)
-            
-            # ============================================
-            # 1. DETECTION AGENT - Anomaly Detection
-            # ============================================
-            logger.info(f"True ARF OSS: Detection agent analyzing {scenario_name}")
-            self.agent_stats["detection_calls"] += 1
-            
-            detection_result = await self._run_detection_agent(
-                component, telemetry, metrics, business_impact
-            )
-            
-            if not detection_result["anomaly_detected"]:
-                logger.info(f"No anomalies detected in {scenario_name}")
-                return self._create_no_anomaly_result(scenario_name, start_time)
-            
-            # ============================================
-            # 2. RECALL AGENT - RAG Similarity Search
-            # ============================================
-            logger.info(f"True ARF OSS: Recall agent searching for similar incidents")
-            self.agent_stats["recall_calls"] += 1
-            
-            # Prepare context for RAG search
-            rag_context = self._prepare_rag_context(
-                component, metrics, business_impact, detection_result
-            )
-            
-            # Find similar incidents using OSS MCP client's RAG capabilities
-            similar_incidents = await self._run_recall_agent(
-                mcp_client, component, rag_context
-            )
-            
-            # ============================================
-            # 3. DECISION AGENT - Healing Intent Generation
-            # ============================================
-            logger.info(f"True ARF OSS: Decision agent generating healing intent")
-            self.agent_stats["decision_calls"] += 1
-            
-            # Determine appropriate action based on scenario
-            action = self._determine_action(scenario_name, component, metrics)
-            
-            # Calculate confidence based on detection and recall
-            confidence = self._calculate_confidence(
-                detection_result, similar_incidents, scenario_name
-            )
-            
-            # Generate healing intent using OSS MCP client
-            healing_intent = await self._run_decision_agent(
-                mcp_client, action, component, metrics, 
-                similar_incidents, confidence, rag_context
-            )
-            
-            # ============================================
-            # COMPILE FINAL RESULTS
-            # ============================================
-            analysis_time_ms = (time.time() - start_time) * 1000
-            self.agent_stats["total_time_ms"] += analysis_time_ms
-            
-            result = self._compile_results(
-                scenario_name=scenario_name,
-                detection_result=detection_result,
-                similar_incidents=similar_incidents,
-                healing_intent=healing_intent,
-                analysis_time_ms=analysis_time_ms,
-                component=component,
-                metrics=metrics
-            )
-            
-            logger.info(f"True ARF OSS: Analysis complete for {scenario_name} "
-                       f"({analysis_time_ms:.1f}ms, confidence: {confidence:.2f})")
-            
-            return result
-            
-        except Exception as e:
-            logger.error(f"True ARF OSS analysis failed: {e}", exc_info=True)
-            return self._create_error_result(scenario_name, str(e), start_time)
-    
-    def _scenario_to_telemetry(self, scenario_name: str, component: str, 
-                              metrics: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Convert scenario metrics to telemetry data format"""
-        telemetry = []
-        current_time = time.time()
-        
-        # Create telemetry points for each metric
-        for metric_name, value in metrics.items():
-            if isinstance(value, (int, float)):
-                # Create 5 data points showing anomaly progression
-                for i in range(5, 0, -1):
-                    telemetry.append({
-                        "timestamp": current_time - (i * 10),  # 10-second intervals
-                        "metric": metric_name,
-                        "value": value * (0.7 + 0.3 * (i/5)),  # Gradual increase
-                        "component": component
-                    })
-        
-        return telemetry
-    
-    async def _run_detection_agent(self, component: str, telemetry: List[Dict[str, Any]],
-                                 metrics: Dict[str, Any], 
-                                 business_impact: Dict[str, Any]) -> Dict[str, Any]:
-        """Run detection agent to find anomalies"""
-        
-        # Analyze each metric for anomalies
-        anomalies = []
-        anomaly_confidence = 0.0
-        
-        for metric_name, value in metrics.items():
-            if not isinstance(value, (int, float)):
-                continue
-                
-            # Define thresholds based on metric type
-            thresholds = self._get_metric_thresholds(metric_name, value)
-            
-            # Check if metric exceeds thresholds
-            if value >= thresholds["critical"]:
-                anomalies.append({
-                    "metric": metric_name,
-                    "value": value,
-                    "threshold": thresholds["critical"],
-                    "severity": "critical",
-                    "confidence": 0.95
-                })
-                anomaly_confidence = max(anomaly_confidence, 0.95)
-            elif value >= thresholds["warning"]:
-                anomalies.append({
-                    "metric": metric_name,
-                    "value": value,
-                    "threshold": thresholds["warning"],
-                    "severity": "high",
-                    "confidence": 0.85
-                })
-                anomaly_confidence = max(anomaly_confidence, 0.85)
-        
-        # Calculate overall severity
-        severity = "critical" if any(a["severity"] == "critical" for a in anomalies) else \
-                  "high" if anomalies else "normal"
-        
-        # Check business impact for additional severity context
-        if business_impact.get("revenue_loss_per_hour", 0) > 5000:
-            severity = "critical"
-            anomaly_confidence = max(anomaly_confidence, 0.97)
-        
-        return {
-            "anomaly_detected": len(anomalies) > 0,
-            "anomalies": anomalies,
-            "severity": severity,
-            "confidence": anomaly_confidence if anomalies else 0.0,
-            "component": component,
-            "timestamp": time.time()
-        }
-    
-    def _get_metric_thresholds(self, metric_name: str, value: float) -> Dict[str, float]:
-        """Get thresholds for different metric types"""
-        # Default thresholds
-        thresholds = {
-            "warning": value * 0.7,  # 70% of current value
-            "critical": value * 0.85  # 85% of current value
-        }
-        
-        # Metric-specific thresholds
-        metric_thresholds = {
-            "cache_hit_rate": {"warning": 50, "critical": 30},
-            "database_load": {"warning": 80, "critical": 90},
-            "response_time_ms": {"warning": 500, "critical": 1000},
-            "error_rate": {"warning": 5, "critical": 10},
-            "memory_usage": {"warning": 85, "critical": 95},
-            "latency_ms": {"warning": 200, "critical": 500},
-            "throughput_mbps": {"warning": 1000, "critical": 500},
-        }
-        
-        if metric_name in metric_thresholds:
-            thresholds = metric_thresholds[metric_name]
-        
-        return thresholds
-    
-    def _prepare_rag_context(self, component: str, metrics: Dict[str, Any],
-                           business_impact: Dict[str, Any],
-                           detection_result: Dict[str, Any]) -> Dict[str, Any]:
-        """Prepare context for RAG similarity search"""
-        return {
-            "component": component,
-            "metrics": metrics,
-            "business_impact": business_impact,
-            "detection": {
-                "severity": detection_result["severity"],
-                "confidence": detection_result["confidence"],
-                "anomaly_count": len(detection_result["anomalies"])
-            },
-            "incident_id": f"inc_{uuid.uuid4().hex[:8]}",
-            "timestamp": time.time(),
-            "environment": "production"
-        }
-    
-    async def _run_recall_agent(self, mcp_client, component: str, 
-                              context: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Run recall agent to find similar incidents using RAG"""
-        try:
-            # Use OSS MCP client's RAG capabilities
-            # The OSS MCP client has _query_rag_for_similar_incidents method
-            similar_incidents = await mcp_client._query_rag_for_similar_incidents(
-                component=component,
-                parameters={},  # Empty parameters for similarity search
-                context=context
-            )
-            
-            # Enhance with success rates if available
-            for incident in similar_incidents:
-                if "success_rate" not in incident:
-                    # Assign random success rate for demo (in real system, this comes from RAG)
-                    incident["success_rate"] = 0.7 + (hash(incident.get("incident_id", "")) % 30) / 100
-            
-            return similar_incidents
-            
-        except Exception as e:
-            logger.warning(f"Recall agent RAG query failed: {e}")
-            # Return mock similar incidents for demo
-            return self._create_mock_similar_incidents(component, context)
-    
-    def _create_mock_similar_incidents(self, component: str, 
-                                     context: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Create mock similar incidents for demo purposes"""
-        incidents = []
-        base_time = time.time() - (30 * 24 * 3600)  # 30 days ago
-        
-        for i in range(3):
-            incidents.append({
-                "incident_id": f"sim_{uuid.uuid4().hex[:8]}",
-                "component": component,
-                "severity": context["detection"]["severity"],
-                "similarity_score": 0.85 - (i * 0.1),
-                "success_rate": 0.8 + (i * 0.05),
-                "resolution_time_minutes": 45 - (i * 10),
-                "timestamp": base_time + (i * 7 * 24 * 3600),  # Weekly intervals
-                "action_taken": "scale_out" if i % 2 == 0 else "restart_container",
-                "success": True
-            })
-        
-        return incidents
-    
-    def _determine_action(self, scenario_name: str, component: str, 
-                         metrics: Dict[str, Any]) -> str:
-        """Determine appropriate healing action based on scenario"""
-        # Map scenarios to actions
-        scenario_actions = {
-            "Cache Miss Storm": "scale_out",
-            "Database Connection Pool Exhaustion": "scale_out",
-            "Kubernetes Memory Leak": "restart_container",
-            "API Rate Limit Storm": "circuit_breaker",
-            "Network Partition": "alert_team",
-            "Storage I/O Saturation": "scale_out",
-        }
-        
-        # Default action based on component
-        component_actions = {
-            "redis_cache": "scale_out",
-            "postgresql_database": "scale_out",
-            "java_payment_service": "restart_container",
-            "external_api_gateway": "circuit_breaker",
-            "distributed_database": "alert_team",
-            "storage_cluster": "scale_out",
-        }
-        
-        # Try scenario-specific action first
-        if scenario_name in scenario_actions:
-            return scenario_actions[scenario_name]
-        
-        # Fall back to component-based action
-        return component_actions.get(component, "alert_team")
-    
-    def _calculate_confidence(self, detection_result: Dict[str, Any],
-                            similar_incidents: List[Dict[str, Any]],
-                            scenario_name: str) -> float:
-        """Calculate confidence score for the healing intent"""
-        base_confidence = detection_result["confidence"]
-        
-        # Boost for similar incidents
-        if similar_incidents:
-            avg_similarity = sum(i.get("similarity_score", 0.0) 
-                               for i in similar_incidents) / len(similar_incidents)
-            similarity_boost = min(0.2, avg_similarity * 0.3)
-            base_confidence += similarity_boost
-            
-            # Boost for successful similar incidents
-            success_rates = [i.get("success_rate", 0.0) for i in similar_incidents]
-            avg_success = sum(success_rates) / len(success_rates)
-            success_boost = min(0.15, avg_success * 0.2)
-            base_confidence += success_boost
-        
-        # Scenario-specific adjustments
-        scenario_boosts = {
-            "Cache Miss Storm": 0.05,
-            "Database Connection Pool Exhaustion": 0.03,
-            "Kubernetes Memory Leak": 0.04,
-            "API Rate Limit Storm": 0.02,
-            "Network Partition": 0.01,
-            "Storage I/O Saturation": 0.03,
-        }
-        
-        base_confidence += scenario_boosts.get(scenario_name, 0.0)
-        
-        # Cap at 0.99 (never 100% certain)
-        return min(base_confidence, 0.99)
-    
-    async def _run_decision_agent(self, mcp_client, action: str, component: str,
-                                metrics: Dict[str, Any], similar_incidents: List[Dict[str, Any]],
-                                confidence: float, context: Dict[str, Any]) -> Dict[str, Any]:
-        """Run decision agent to generate healing intent"""
-        try:
-            # Determine parameters based on action and metrics
-            parameters = self._determine_parameters(action, metrics)
-            
-            # Generate justification
-            justification = self._generate_justification(
-                action, component, metrics, similar_incidents, confidence
-            )
-            
-            # Use OSS MCP client to analyze and create healing intent
-            analysis_result = await mcp_client.analyze_and_recommend(
-                tool_name=action,
-                component=component,
-                parameters=parameters,
-                context={
-                    **context,
-                    "justification": justification,
-                    "similar_incidents": similar_incidents,
-                    "confidence": confidence
-                },
-                use_rag=True
-            )
-            
-            # Extract healing intent from analysis result
-            healing_intent = analysis_result.healing_intent
-            
-            # Convert to dictionary format for demo
-            return {
-                "action": healing_intent.action,
-                "component": healing_intent.component,
-                "parameters": healing_intent.parameters,
-                "confidence": healing_intent.confidence,
-                "justification": healing_intent.justification,
-                "requires_enterprise": healing_intent.requires_enterprise,
-                "oss_advisory": healing_intent.is_oss_advisory,
-                "similar_incidents_count": len(similar_incidents),
-                "rag_similarity_score": healing_intent.rag_similarity_score,
-                "timestamp": time.time(),
-                "arf_version": "3.3.9"  # FIXED: Updated from 3.3.7 to 3.3.9
-            }
-            
-        except Exception as e:
-            logger.error(f"Decision agent failed: {e}")
-            # Create fallback healing intent
-            return self._create_fallback_intent(action, component, metrics, confidence)
-    
-    def _determine_parameters(self, action: str, metrics: Dict[str, Any]) -> Dict[str, Any]:
-        """Determine parameters for the healing action"""
-        if action == "scale_out":
-            # Scale factor based on severity of metrics
-            max_metric = max((v for v in metrics.values() if isinstance(v, (int, float))), default=1)
-            scale_factor = 2 if max_metric > 80 else 1
-            
-            return {
-                "scale_factor": scale_factor,
-                "resource_profile": "standard",
-                "strategy": "gradual"
-            }
-        
-        elif action == "restart_container":
-            return {
-                "grace_period": 30,
-                "force": False
-            }
-        
-        elif action == "circuit_breaker":
-            return {
-                "threshold": 0.5,
-                "timeout": 60,
-                "half_open_after": 300
-            }
-        
-        elif action == "alert_team":
-            return {
-                "severity": "critical",
-                "channels": ["slack", "email"],
-                "escalate_after_minutes": 5
-            }
-        
-        elif action == "rollback":
-            return {
-                "revision": "previous",
-                "verify": True
-            }
-        
-        elif action == "traffic_shift":
-            return {
-                "percentage": 50,
-                "target": "canary"
-            }
-        
-        return {}
-    
-    def _generate_justification(self, action: str, component: str, metrics: Dict[str, Any],
-                              similar_incidents: List[Dict[str, Any]], confidence: float) -> str:
-        """Generate human-readable justification"""
-        if similar_incidents:
-            similar_count = len(similar_incidents)
-            avg_success = sum(i.get("success_rate", 0.0) for i in similar_incidents) / similar_count
-            
-            return (
-                f"Detected anomalies in {component} with {confidence:.0%} confidence. "
-                f"Found {similar_count} similar historical incidents with {avg_success:.0%} average success rate. "
-                f"Recommended {action} based on pattern matching and historical effectiveness."
-            )
-        else:
-            critical_metrics = []
-            for metric, value in metrics.items():
-                if isinstance(value, (int, float)) and value > 80:  # Threshold
-                    critical_metrics.append(f"{metric}: {value}")
-            
-            return (
-                f"Detected anomalies in {component} with {confidence:.0%} confidence. "
-                f"Critical metrics: {', '.join(critical_metrics[:3])}. "
-                f"Recommended {action} based on anomaly characteristics and component type."
-            )
-    
-    def _create_fallback_intent(self, action: str, component: str,
-                              metrics: Dict[str, Any], confidence: float) -> Dict[str, Any]:
-        """Create fallback healing intent when decision agent fails"""
-        return {
-            "action": action,
-            "component": component,
-            "parameters": {"fallback": True},
-            "confidence": confidence * 0.8,  # Reduced confidence for fallback
-            "justification": f"Fallback recommendation for {component} anomalies",
-            "requires_enterprise": True,
-            "oss_advisory": True,
-            "similar_incidents_count": 0,
-            "rag_similarity_score": None,
-            "timestamp": time.time(),
-            "arf_version": "3.3.9"  # FIXED: Updated from 3.3.7 to 3.3.9
-        }
-    
-    def _compile_results(self, scenario_name: str, detection_result: Dict[str, Any],
-                        similar_incidents: List[Dict[str, Any]], healing_intent: Dict[str, Any],
-                        analysis_time_ms: float, component: str, metrics: Dict[str, Any]) -> Dict[str, Any]:
-        """Compile all analysis results into final format"""
-        
-        return {
-            "status": "success",
-            "scenario": scenario_name,
-            "analysis": {
-                "detection": detection_result,
-                "recall": similar_incidents,
-                "decision": healing_intent
-            },
-            "capabilities": {
-                "execution_allowed": False,
-                "mcp_modes": ["advisory"],
-                "oss_boundary": "advisory_only",
-                "requires_enterprise": True,
-            },
-            "agents_used": ["Detection", "Recall", "Decision"],
-            "analysis_time_ms": analysis_time_ms,
-            "arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-            "oss_edition": True,
-            "demo_display": {
-                "real_arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-                "true_oss_used": True,
-                "enterprise_simulated": False,
-                "agent_details": {
-                    "detection_confidence": detection_result["confidence"],
-                    "similar_incidents_count": len(similar_incidents),
-                    "decision_confidence": healing_intent["confidence"],
-                    "healing_action": healing_intent["action"],
-                }
-            }
-        }
-    
-    def _create_no_anomaly_result(self, scenario_name: str, start_time: float) -> Dict[str, Any]:
-        """Create result when no anomalies are detected"""
-        analysis_time_ms = (time.time() - start_time) * 1000
-        
-        return {
-            "status": "success",
-            "scenario": scenario_name,
-            "result": "no_anomalies_detected",
-            "analysis_time_ms": analysis_time_ms,
-            "arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-            "oss_edition": True,
-            "demo_display": {
-                "real_arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-                "true_oss_used": True,
-                "no_anomalies": True
-            }
-        }
-    
-    def _create_error_result(self, scenario_name: str, error: str, 
-                           start_time: float) -> Dict[str, Any]:
-        """Create error result"""
-        analysis_time_ms = (time.time() - start_time) * 1000
-        
-        return {
-            "status": "error",
-            "error": error,
-            "scenario": scenario_name,
-            "analysis_time_ms": analysis_time_ms,
-            "arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-            "oss_edition": True,
-            "demo_display": {
-                "real_arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-                "true_oss_used": True,
-                "error": error[:100]
-            }
-        }
-    
-    def get_agent_stats(self) -> Dict[str, Any]:
-        """Get statistics from all agents"""
-        return {
-            **self.agent_stats,
-            "oss_available": self.oss_available,
-            "arf_version": "3.3.9",  # FIXED: Updated from 3.3.7 to 3.3.9
-            "avg_analysis_time_ms": (
-                self.agent_stats["total_time_ms"] / self.agent_stats["total_analyses"]
-                if self.agent_stats["total_analyses"] > 0 else 0
-            )
-        }
-
-
-# ============================================================================
-# FACTORY FUNCTION
-# ============================================================================
-
-async def get_true_arf_oss(config: Optional[Dict[str, Any]] = None) -> TrueARFOSS:
-    """
-    Factory function for TrueARFOSS
-    
-    This is the function that TrueARF337Orchestrator expects to call.
-    
-    Args:
-        config: Optional configuration
-        
-    Returns:
-        TrueARFOSS instance
-    """
-    return TrueARFOSS(config)
-
-
-# ============================================================================
-# SIMPLE MOCK FOR BACKWARDS COMPATIBILITY
-# ============================================================================
-
-async def get_mock_true_arf_oss(config: Optional[Dict[str, Any]] = None) -> TrueARFOSS:
-    """
-    Mock version for when dependencies are missing
-    """
-    logger.warning("Using mock TrueARFOSS - real implementation not available")
-    
-    class MockTrueARFOSS:
-        def __init__(self, config):
-            self.config = config or {}
-            self.oss_available = False
-        
-        async def analyze_scenario(self, scenario_name, scenario_data):
-            return {
-                "status": "mock",
-                "scenario": scenario_name,
-                "message": "Mock analysis - install true ARF OSS v3.3.9 for real analysis",  # FIXED: Updated version
-                "demo_display": {
-                    "real_arf_version": "mock",
-                    "true_oss_used": False,
-                    "enterprise_simulated": False,
-                }
-            }
-    
-    return MockTrueARFOSS(config)
-
-
-# ============================================================================
-# MAIN ENTRY POINT
-# ============================================================================
-
-if __name__ == "__main__":
-    # Test the implementation
-    import asyncio
-    
-    async def test():
-        # Create test scenario
-        scenario = {
-            "component": "redis_cache",
-            "metrics": {
-                "cache_hit_rate": 18.5,
-                "database_load": 92,
-                "response_time_ms": 1850,
-            },
-            "business_impact": {
-                "revenue_loss_per_hour": 8500
-            }
-        }
-        
-        arf = await get_true_arf_oss()
-        result = await arf.analyze_scenario("Test Cache Miss Storm", scenario)
-        print("Test Result:", json.dumps(result, indent=2, default=str))
-    
-    asyncio.run(test())

core/visualizations.py

@@ -1,876 +0,0 @@
-"""
-Enhanced visualization engine for ARF Demo with clear boundary indicators
-FIXED VERSION: Works even when Plotly fails, shows clear real/simulated boundaries
-"""
-
-import logging
-from typing import Dict, List, Any, Optional, Tuple
-import random
-
-logger = logging.getLogger(__name__)
-
-# Try to import Plotly, but have fallbacks
-try:
-    import plotly.graph_objects as go
-    import plotly.express as px
-    import numpy as np
-    PLOTLY_AVAILABLE = True
-    logger.info("✅ Plotly available for advanced visualizations")
-except ImportError as e:
-    PLOTLY_AVAILABLE = False
-    logger.warning(f"⚠️ Plotly not available: {e}. Using HTML fallback visualizations.")
-
-
-class EnhancedVisualizationEngine:
-    """Enhanced visualization engine with boundary awareness and fallbacks"""
-    
-    def __init__(self):
-        self.color_palette = {
-            "primary": "#3b82f6",
-            "success": "#10b981",
-            "warning": "#f59e0b",
-            "danger": "#ef4444",
-            "info": "#8b5cf6",
-            "dark": "#1e293b",
-            "light": "#f8fafc",
-            "real_arf": "#10b981",  # Green for real ARF
-            "simulated": "#f59e0b",  # Amber for simulated
-            "mock": "#64748b",  # Gray for mock
-        }
-        
-    def create_executive_dashboard(self, data: Optional[Dict] = None, is_real_arf: bool = True) -> Any:
-        """
-        Create executive dashboard with clear boundary indicators
-        
-        Args:
-            data: Dashboard data
-            is_real_arf: Whether this is real ARF or simulated/mock
-        
-        Returns:
-            Plotly figure or HTML fallback
-        """
-        if data is None:
-            data = {"roi_multiplier": 5.2}
-        
-        roi_multiplier = data.get("roi_multiplier", 5.2)
-        
-        if not PLOTLY_AVAILABLE:
-            # HTML fallback
-            return self._create_html_dashboard(roi_multiplier, is_real_arf)
-        
-        try:
-            # Create a multi-panel executive dashboard with boundary indicators
-            fig = go.Figure()
-            
-            # Main ROI gauge with boundary indicator
-            boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-            boundary_text = "REAL ARF OSS" if is_real_arf else "SIMULATED"
-            
-            fig.add_trace(go.Indicator(
-                mode="number+gauge",
-                value=roi_multiplier,
-                title={
-                    "text": f"<b>ROI Multiplier</b><br>"
-                           f"<span style='font-size: 12px; color: {boundary_color}'>"
-                           f"💎 {boundary_text}</span>"
-                },
-                domain={'x': [0.25, 0.75], 'y': [0.6, 1]},
-                gauge={
-                    'axis': {'range': [0, 10], 'tickwidth': 1},
-                    'bar': {'color': boundary_color},
-                    'steps': [
-                        {'range': [0, 2], 'color': '#e5e7eb'},
-                        {'range': [2, 4], 'color': '#d1d5db'},
-                        {'range': [4, 6], 'color': '#10b981'},
-                        {'range': [6, 10], 'color': '#059669'}
-                    ],
-                    'threshold': {
-                        'line': {'color': "black", 'width': 4},
-                        'thickness': 0.75,
-                        'value': roi_multiplier
-                    }
-                }
-            ))
-            
-            # Add boundary indicator in top right
-            fig.add_annotation(
-                x=0.98, y=0.98,
-                xref="paper", yref="paper",
-                text=f"💎 {boundary_text}",
-                showarrow=False,
-                font=dict(size=14, color=boundary_color, family="Arial, sans-serif"),
-                bgcolor="white",
-                bordercolor=boundary_color,
-                borderwidth=2,
-                borderpad=4,
-                opacity=0.9
-            )
-            
-            # Add secondary metrics with clear sourcing
-            source_text = "Real ARF OSS" if is_real_arf else "Demo Simulation"
-            
-            fig.add_trace(go.Indicator(
-                mode="number",
-                value=85,
-                title={
-                    "text": f"MTTR Reduction<br>"
-                           f"<span style='font-size: 10px; color: #64748b'>{source_text}</span>"
-                },
-                number={'suffix': "%", 'font': {'size': 24}},
-                domain={'x': [0.1, 0.4], 'y': [0.2, 0.5]}
-            ))
-            
-            fig.add_trace(go.Indicator(
-                mode="number",
-                value=94,
-                title={
-                    "text": f"Detection Accuracy<br>"
-                           f"<span style='font-size: 10px; color: #64748b'>{source_text}</span>"
-                },
-                number={'suffix': "%", 'font': {'size': 24}},
-                domain={'x': [0.6, 0.9], 'y': [0.2, 0.5]}
-            ))
-            
-            fig.update_layout(
-                height=700,
-                paper_bgcolor="rgba(0,0,0,0)",
-                plot_bgcolor="rgba(0,0,0,0)",
-                font={'family': "Arial, sans-serif"},
-                margin=dict(t=50, b=50, l=50, r=50),
-                title=f"📊 Executive Dashboard - ARF v3.3.7<br>"
-                     f"<span style='font-size: 14px; color: {boundary_color}'>"
-                     f"Mode: {boundary_text}</span>"
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Plotly dashboard creation failed: {e}")
-            return self._create_html_dashboard(roi_multiplier, is_real_arf)
-    
-    def _create_html_dashboard(self, roi_multiplier: float, is_real_arf: bool) -> str:
-        """Create HTML fallback dashboard"""
-        boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-        boundary_text = "REAL ARF OSS" if is_real_arf else "SIMULATED"
-        
-        return f"""
-        <div style="border: 2px solid {boundary_color}; border-radius: 16px; padding: 25px; 
-                   background: linear-gradient(135deg, #ffffff 0%, #f8fafc 100%); 
-                   box-shadow: 0 8px 32px rgba(0,0,0,0.1);">
-            
-            <!-- Boundary indicator -->
-            <div style="position: absolute; top: 15px; right: 15px; padding: 6px 12px; 
-                       background: {boundary_color}; color: white; border-radius: 20px; 
-                       font-size: 12px; font-weight: bold; display: flex; align-items: center; gap: 6px;">
-                💎 {boundary_text}
-            </div>
-            
-            <h3 style="margin: 0 0 20px 0; color: #1e293b; font-size: 20px; font-weight: 700;">
-                📊 Executive Dashboard - ARF v3.3.7
-            </h3>
-            
-            <!-- Main ROI Gauge -->
-            <div style="text-align: center; margin: 30px 0;">
-                <div style="font-size: 14px; color: #64748b; margin-bottom: 10px; font-weight: 500;">
-                    ROI Multiplier
-                </div>
-                <div style="position: relative; width: 160px; height: 160px; margin: 0 auto;">
-                    <!-- Background circle -->
-                    <div style="position: absolute; width: 160px; height: 160px; 
-                               border-radius: 50%; background: #f1f5f9; border: 10px solid #e2e8f0;"></div>
-                    <!-- ROI arc -->
-                    <div style="position: absolute; width: 160px; height: 160px; 
-                               border-radius: 50%; 
-                               background: conic-gradient({boundary_color} 0% {roi_multiplier*10}%, #e2e8f0 {roi_multiplier*10}% 100%);
-                               border: 10px solid transparent; clip-path: polygon(50% 50%, 100% 0, 100% 100%);"></div>
-                    <!-- Center value -->
-                    <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
-                               font-size: 32px; font-weight: 800; color: {boundary_color};">
-                        {roi_multiplier:.1f}×
-                    </div>
-                </div>
-                <div style="margin-top: 15px; font-size: 12px; color: {boundary_color}; font-weight: 600;">
-                    {boundary_text} Analysis
-                </div>
-            </div>
-            
-            <!-- Secondary metrics -->
-            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-top: 30px;">
-                <div style="text-align: center; padding: 15px; background: #f8fafc; border-radius: 12px;">
-                    <div style="font-size: 12px; color: #64748b; margin-bottom: 8px;">MTTR Reduction</div>
-                    <div style="font-size: 28px; font-weight: 700; color: #10b981;">85%</div>
-                    <div style="font-size: 10px; color: #94a3b8; margin-top: 4px;">{boundary_text}</div>
-                </div>
-                
-                <div style="text-align: center; padding: 15px; background: #f8fafc; border-radius: 12px;">
-                    <div style="font-size: 12px; color: #64748b; margin-bottom: 8px;">Detection Accuracy</div>
-                    <div style="font-size: 28px; font-weight=700; color: #10b981;">94%</div>
-                    <div style="font-size: 10px; color: #94a3b8; margin-top: 4px;">{boundary_text}</div>
-                </div>
-            </div>
-            
-            <!-- Data source note -->
-            <div style="margin-top: 25px; padding: 12px; background: #f1f5f9; border-radius: 8px; border-left: 4px solid {boundary_color};">
-                <div style="font-size: 12px; color: #475569; line-height: 1.5;">
-                    <strong>📈 Data Source:</strong> {boundary_text} v3.3.7 • 
-                    <strong>⚡ Processing:</strong> Real-time analysis • 
-                    <strong>🎯 Confidence:</strong> Deterministic scoring
-                </div>
-            </div>
-        </div>
-        """
-    
-    def create_telemetry_plot(self, scenario_name: str, anomaly_detected: bool = True, 
-                            is_real_arf: bool = True) -> Any:
-        """Create telemetry plot with boundary indicators"""
-        if not PLOTLY_AVAILABLE:
-            return self._create_html_telemetry(scenario_name, anomaly_detected, is_real_arf)
-        
-        try:
-            import numpy as np
-            
-            # Generate realistic telemetry data
-            time_points = np.arange(0, 100, 1)
-            
-            # Different patterns for different scenarios
-            if "Cache" in scenario_name:
-                base_data = 100 + 50 * np.sin(time_points * 0.2)
-                noise = np.random.normal(0, 8, 100)
-                metric_name = "Cache Hit Rate (%)"
-                normal_range = (70, 95)
-            elif "Database" in scenario_name:
-                base_data = 70 + 30 * np.sin(time_points * 0.15)
-                noise = np.random.normal(0, 6, 100)
-                metric_name = "Connection Pool Usage"
-                normal_range = (20, 60)
-            elif "Memory" in scenario_name:
-                base_data = 50 + 40 * np.sin(time_points * 0.1)
-                noise = np.random.normal(0, 10, 100)
-                metric_name = "Memory Usage (%)"
-                normal_range = (40, 80)
-            else:
-                base_data = 80 + 20 * np.sin(time_points * 0.25)
-                noise = np.random.normal(0, 5, 100)
-                metric_name = "System Load"
-                normal_range = (50, 90)
-            
-            data = base_data + noise
-            
-            fig = go.Figure()
-            
-            boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-            boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-            
-            if anomaly_detected:
-                # Normal operation
-                fig.add_trace(go.Scatter(
-                    x=time_points[:70],
-                    y=data[:70],
-                    mode='lines',
-                    name='Normal Operation',
-                    line=dict(color=self.color_palette["primary"], width=3),
-                    fill='tozeroy',
-                    fillcolor='rgba(59, 130, 246, 0.1)'
-                ))
-                
-                # Anomaly period
-                fig.add_trace(go.Scatter(
-                    x=time_points[70:],
-                    y=data[70:],
-                    mode='lines',
-                    name='🚨 Anomaly Detected',
-                    line=dict(color=self.color_palette["danger"], width=3, dash='dash'),
-                    fill='tozeroy',
-                    fillcolor='rgba(239, 68, 68, 0.1)'
-                ))
-                
-                # Add detection point
-                fig.add_vline(
-                    x=70,
-                    line_dash="dash",
-                    line_color=self.color_palette["success"],
-                    annotation_text=f"ARF Detection ({boundary_text})",
-                    annotation_position="top",
-                    annotation_font_color=boundary_color
-                )
-            else:
-                # All normal
-                fig.add_trace(go.Scatter(
-                    x=time_points,
-                    y=data,
-                    mode='lines',
-                    name=metric_name,
-                    line=dict(color=self.color_palette["primary"], width=3),
-                    fill='tozeroy',
-                    fillcolor='rgba(59, 130, 246, 0.1)'
-                ))
-            
-            # Add normal range
-            fig.add_hrect(
-                y0=normal_range[0],
-                y1=normal_range[1],
-                fillcolor="rgba(16, 185, 129, 0.1)",
-                opacity=0.2,
-                line_width=0,
-                annotation_text="Normal Range",
-                annotation_position="top left"
-            )
-            
-            # Add boundary indicator
-            fig.add_annotation(
-                x=0.02, y=0.98,
-                xref="paper", yref="paper",
-                text=f"💎 {boundary_text}",
-                showarrow=False,
-                font=dict(size=12, color=boundary_color),
-                bgcolor="white",
-                bordercolor=boundary_color,
-                borderwidth=2,
-                borderpad=4
-            )
-            
-            fig.update_layout(
-                title=f"📈 {metric_name} - Live Telemetry<br>"
-                     f"<span style='font-size: 12px; color: #64748b'>"
-                     f"ARF v3.3.7 • {boundary_text} Analysis</span>",
-                xaxis_title="Time (minutes)",
-                yaxis_title=metric_name,
-                height=350,
-                margin=dict(l=20, r=20, t=70, b=20),
-                plot_bgcolor='rgba(0,0,0,0)',
-                paper_bgcolor='rgba(0,0,0,0)',
-                legend=dict(
-                    orientation="h",
-                    yanchor="bottom",
-                    y=1.02,
-                    xanchor="right",
-                    x=1
-                )
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Telemetry plot creation failed: {e}")
-            return self._create_html_telemetry(scenario_name, anomaly_detected, is_real_arf)
-    
-    def _create_html_telemetry(self, scenario_name: str, anomaly_detected: bool, is_real_arf: bool) -> str:
-        """HTML fallback for telemetry visualization"""
-        boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-        boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-        
-        if "Cache" in scenario_name:
-            metric_name = "Cache Hit Rate"
-            normal_range = (70, 95)
-            current_value = 18 if anomaly_detected else 85
-        elif "Database" in scenario_name:
-            metric_name = "Connection Pool Usage"
-            normal_range = (20, 60)
-            current_value = 92 if anomaly_detected else 45
-        else:
-            metric_name = "System Load"
-            normal_range = (50, 90)
-            current_value = 185 if anomaly_detected else 65
-        
-        # Calculate position in range
-        percentage = ((current_value - normal_range[0]) / (normal_range[1] - normal_range[0])) * 100
-        percentage = max(0, min(100, percentage))
-        
-        return f"""
-        <div style="border: 2px solid {boundary_color}; border-radius: 16px; padding: 20px; 
-                   background: white; box-shadow: 0 4px 12px rgba(0,0,0,0.05);">
-            
-            <!-- Boundary indicator -->
-            <div style="position: absolute; top: 15px; right: 15px; padding: 4px 10px; 
-                       background: {boundary_color}; color: white; border-radius: 15px; 
-                       font-size: 11px; font-weight: bold; display: flex; align-items: center; gap: 5px;">
-                💎 {boundary_text}
-            </div>
-            
-            <h4 style="margin: 0 0 15px 0; color: #1e293b; font-size: 16px; font-weight: 600;">
-                📈 {metric_name} - Live Telemetry
-            </h4>
-            
-            <!-- Simplified timeline -->
-            <div style="position: relative; height: 100px; margin: 20px 0;">
-                <!-- Background line -->
-                <div style="position: absolute; left: 0; right: 0; top: 50%; 
-                           height: 2px; background: #e2e8f0; transform: translateY(-50%);"></div>
-                
-                <!-- Normal range -->
-                <div style="position: absolute; left: 10%; right: 40%; top: 50%; 
-                           height: 6px; background: #10b981; transform: translateY(-50%); 
-                           border-radius: 3px; opacity: 0.3;"></div>
-                
-                <!-- Anomaly point -->
-                <div style="position: absolute; left: 70%; top: 50%; 
-                           transform: translate(-50%, -50%);">
-                    <div style="width: 20px; height: 20px; border-radius: 50%; 
-                               background: {'#ef4444' if anomaly_detected else '#10b981'}; 
-                               border: 3px solid white; box-shadow: 0 0 0 2px {'#ef4444' if anomaly_detected else '#10b981'};">
-                    </div>
-                    <div style="position: absolute; top: 25px; left: 50%; transform: translateX(-50%);
-                               white-space: nowrap; font-size: 11px; color: #64748b;">
-                        {current_value}
-                    </div>
-                </div>
-                
-                <!-- Labels -->
-                <div style="position: absolute; left: 10%; top: 70px; font-size: 11px; color: #64748b;">
-                    Normal: {normal_range[0]}
-                </div>
-                <div style="position: absolute; left: 40%; top: 70px; font-size: 11px; color: #64748b;">
-                    Warning: {normal_range[1]}
-                </div>
-                <div style="position: absolute; left: 70%; top: 70px; font-size: 11px; 
-                           color: {'#ef4444' if anomaly_detected else '#10b981'}; font-weight: 500;">
-                    Current: {current_value}
-                </div>
-            </div>
-            
-            <!-- Status indicator -->
-            <div style="display: flex; justify-content: space-between; align-items: center; 
-                       margin-top: 15px; padding: 10px; background: #f8fafc; border-radius: 8px;">
-                <div>
-                    <div style="font-size: 12px; color: #64748b;">Status</div>
-                    <div style="font-size: 14px; color: {'#ef4444' if anomaly_detected else '#10b981'}; 
-                               font-weight: 600;">
-                        {'🚨 Anomaly Detected' if anomaly_detected else '✅ Normal'}
-                    </div>
-                </div>
-                <div style="text-align: right;">
-                    <div style="font-size: 12px; color: #64748b;">ARF Mode</div>
-                    <div style="font-size: 14px; color: {boundary_color}; font-weight: 600;">
-                        {boundary_text}
-                    </div>
-                </div>
-            </div>
-        </div>
-        """
-    
-    def create_impact_gauge(self, scenario_name: str, is_real_arf: bool = True) -> Any:
-        """Create business impact gauge with boundary indicators"""
-        impact_map = {
-            "Cache Miss Storm": {"revenue": 8500, "severity": "critical", "users": 45000},
-            "Database Connection Pool Exhaustion": {"revenue": 4200, "severity": "high", "users": 25000},
-            "Kubernetes Memory Leak": {"revenue": 5500, "severity": "high", "users": 35000},
-            "API Rate Limit Storm": {"revenue": 3800, "severity": "medium", "users": 20000},
-            "Network Partition": {"revenue": 12000, "severity": "critical", "users": 75000},
-            "Storage I/O Saturation": {"revenue": 6800, "severity": "high", "users": 30000}
-        }
-        
-        impact = impact_map.get(scenario_name, {"revenue": 5000, "severity": "medium", "users": 30000})
-        
-        if not PLOTLY_AVAILABLE:
-            return self._create_html_impact_gauge(impact, is_real_arf)
-        
-        try:
-            boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-            boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-            severity_color = self._get_severity_color(impact["severity"])
-            
-            fig = go.Figure(go.Indicator(
-                mode="gauge+number",
-                value=impact["revenue"],
-                title={
-                    "text": f"💰 Hourly Revenue Risk<br>"
-                           f"<span style='font-size: 12px; color: {boundary_color}'>"
-                           f"{boundary_text} Analysis</span>"
-                },
-                number={'prefix': "$", 'font': {'size': 28}},
-                gauge={
-                    'axis': {'range': [0, 15000], 'tickwidth': 1},
-                    'bar': {'color': severity_color},
-                    'steps': [
-                        {'range': [0, 3000], 'color': '#10b981'},
-                        {'range': [3000, 7000], 'color': '#f59e0b'},
-                        {'range': [7000, 15000], 'color': '#ef4444'}
-                    ],
-                    'threshold': {
-                        'line': {'color': "black", 'width': 4},
-                        'thickness': 0.75,
-                        'value': impact["revenue"]
-                    }
-                }
-            ))
-            
-            # Add users affected annotation
-            fig.add_annotation(
-                x=0.5, y=0.3,
-                xref="paper", yref="paper",
-                text=f"👥 {impact['users']:,} users affected",
-                showarrow=False,
-                font=dict(size=14, color="#64748b")
-            )
-            
-            fig.update_layout(
-                height=350,
-                margin=dict(l=20, r=20, t=80, b=20),
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)'
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Impact gauge creation failed: {e}")
-            return self._create_html_impact_gauge(impact, is_real_arf)
-    
-    def _create_html_impact_gauge(self, impact: Dict, is_real_arf: bool) -> str:
-        """HTML fallback for impact gauge"""
-        boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-        boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-        severity_color = self._get_severity_color(impact["severity"])
-        
-        # Calculate percentage for gauge
-        revenue = impact["revenue"]
-        percentage = min(100, (revenue / 15000) * 100)
-        
-        return f"""
-        <div style="border: 2px solid {boundary_color}; border-radius: 16px; padding: 20px; 
-                   background: white; box-shadow: 0 4px 12px rgba(0,0,0,0.05); text-align: center;">
-            
-            <!-- Boundary indicator -->
-            <div style="position: absolute; top: 15px; right: 15px; padding: 4px 10px; 
-                       background: {boundary_color}; color: white; border-radius: 15px; 
-                       font-size: 11px; font-weight: bold; display: flex; align-items: center; gap: 5px;">
-                💎 {boundary_text}
-            </div>
-            
-            <h4 style="margin: 0 0 15px 0; color: #1e293b; font-size: 16px; font-weight: 600;">
-                💰 Business Impact
-            </h4>
-            
-            <!-- Revenue gauge -->
-            <div style="position: relative; width: 200px; height: 200px; margin: 0 auto;">
-                <!-- Background circle -->
-                <div style="position: absolute; width: 200px; height: 200px; 
-                           border-radius: 50%; background: #f1f5f9; border: 12px solid #e2e8f0;"></div>
-                
-                <!-- Severity arc -->
-                <div style="position: absolute; width: 200px; height: 200px; 
-                           border-radius: 50%; 
-                           background: conic-gradient({severity_color} 0% {percentage}%, #e2e8f0 {percentage}% 100%);
-                           border: 12px solid transparent; clip-path: polygon(50% 50%, 100% 0, 100% 100%);"></div>
-                
-                <!-- Center value -->
-                <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
-                           font-size: 28px; font-weight: 800; color: {severity_color}; line-height: 1;">
-                    ${revenue:,}<br>
-                    <span style="font-size: 14px; color: #64748b;">per hour</span>
-                </div>
-            </div>
-            
-            <!-- Severity indicator -->
-            <div style="display: inline-block; padding: 6px 16px; background: {severity_color}; 
-                       color: white; border-radius: 20px; font-size: 13px; font-weight: bold; 
-                       margin: 15px 0; text-transform: uppercase;">
-                {impact['severity']} SEVERITY
-            </div>
-            
-            <!-- User impact -->
-            <div style="margin-top: 15px; padding: 12px; background: #f8fafc; border-radius: 10px;">
-                <div style="display: flex; justify-content: space-between; align-items: center;">
-                    <div style="font-size: 13px; color: #64748b;">👥 Users Affected</div>
-                    <div style="font-size: 18px; font-weight: 700; color: #1e293b;">
-                        {impact['users']:,}
-                    </div>
-                </div>
-                <div style="font-size: 11px; color: #94a3b8; margin-top: 5px; text-align: center;">
-                    Analysis: {boundary_text} v3.3.7
-                </div>
-            </div>
-        </div>
-        """
-    
-    def create_timeline_comparison(self, is_real_arf: bool = True) -> Any:
-        """Create timeline comparison chart"""
-        if not PLOTLY_AVAILABLE:
-            return self._create_html_timeline(is_real_arf)
-        
-        try:
-            import numpy as np
-            
-            phases = ["Detection", "Analysis", "Decision", "Execution", "Recovery"]
-            manual_times = [300, 1800, 1200, 1800, 3600]  # seconds
-            arf_times = [45, 30, 60, 720, 0]
-            
-            # Convert to minutes for readability
-            manual_times_min = [t/60 for t in manual_times]
-            arf_times_min = [t/60 for t in arf_times]
-            
-            fig = go.Figure()
-            
-            boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-            boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-            
-            fig.add_trace(go.Bar(
-                name='Manual Process',
-                x=phases,
-                y=manual_times_min,
-                marker_color=self.color_palette["danger"],
-                text=[f"{t:.0f}m" for t in manual_times_min],
-                textposition='auto'
-            ))
-            
-            fig.add_trace(go.Bar(
-                name=f'ARF Autonomous ({boundary_text})',
-                x=phases,
-                y=arf_times_min,
-                marker_color=boundary_color,
-                text=[f"{t:.0f}m" for t in arf_times_min],
-                textposition='auto'
-            ))
-            
-            total_manual = sum(manual_times_min)
-            total_arf = sum(arf_times_min)
-            
-            fig.update_layout(
-                title=f"⏰ Incident Timeline Comparison<br>"
-                     f"<span style='font-size: 14px; color: #6b7280'>"
-                     f"Total: {total_manual:.0f}m manual vs {total_arf:.0f}m ARF "
-                     f"({((total_manual - total_arf) / total_manual * 100):.0f}% faster)</span>",
-                barmode='group',
-                height=400,
-                plot_bgcolor='rgba(0,0,0,0)',
-                paper_bgcolor='rgba(0,0,0,0)',
-                legend=dict(
-                    orientation="h",
-                    yanchor="bottom",
-                    y=1.02,
-                    xanchor="right",
-                    x=1
-                ),
-                yaxis_title="Time (minutes)"
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Timeline comparison creation failed: {e}")
-            return self._create_html_timeline(is_real_arf)
-    
-    def _create_html_timeline(self, is_real_arf: bool) -> str:
-        """HTML fallback for timeline comparison"""
-        boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-        boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-        
-        phases = ["Detection", "Analysis", "Decision", "Execution", "Recovery"]
-        manual_times = [5, 30, 20, 30, 60]  # minutes
-        arf_times = [0.75, 0.5, 1, 12, 0]  # minutes
-        
-        # Calculate totals
-        total_manual = sum(manual_times)
-        total_arf = sum(arf_times)
-        percent_faster = ((total_manual - total_arf) / total_manual) * 100
-        
-        return f"""
-        <div style="border: 2px solid {boundary_color}; border-radius: 16px; padding: 20px; 
-                   background: white; box-shadow: 0 4px 12px rgba(0,0,0,0.05);">
-            
-            <!-- Boundary indicator -->
-            <div style="position: absolute; top: 15px; right: 15px; padding: 4px 10px; 
-                       background: {boundary_color}; color: white; border-radius: 15px; 
-                       font-size: 11px; font-weight: bold; display: flex; align-items: center; gap: 5px;">
-                ⏰ {boundary_text}
-            </div>
-            
-            <h4 style="margin: 0 0 15px 0; color: #1e293b; font-size: 16px; font-weight: 600;">
-                ⏰ Timeline Comparison
-            </h4>
-            
-            <div style="font-size: 13px; color: #64748b; margin-bottom: 20px; line-height: 1.5;">
-                <strong>Manual:</strong> {total_manual:.0f} minutes • 
-                <strong>ARF ({boundary_text}):</strong> {total_arf:.0f} minutes • 
-                <strong>Faster:</strong> {percent_faster:.0f}%
-            </div>
-            
-            <!-- Timeline visualization -->
-            <div style="position: relative; margin: 20px 0;">
-                <!-- Timeline line -->
-                <div style="position: absolute; left: 0; right: 0; top: 20px; 
-                           height: 2px; background: #e2e8f0;"></div>
-                
-                {self._create_timeline_segments(phases, manual_times, arf_times, boundary_color)}
-                
-                <!-- Legend -->
-                <div style="display: flex; gap: 15px; margin-top: 50px; justify-content: center;">
-                    <div style="display: flex; align-items: center; gap: 6px;">
-                        <div style="width: 12px; height: 12px; background: #ef4444; border-radius: 2px;"></div>
-                        <div style="font-size: 12px; color: #64748b;">Manual Process</div>
-                    </div>
-                    <div style="display: flex; align-items: center; gap: 6px;">
-                        <div style="width: 12px; height=12px; background: {boundary_color}; border-radius: 2px;"></div>
-                        <div style="font-size: 12px; color: #64748b;">ARF ({boundary_text})</div>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- Summary -->
-            <div style="margin-top: 20px; padding: 15px; background: #f8fafc; border-radius: 10px;">
-                <div style="font-size: 14px; color: #475569; line-height: 1.6;">
-                    <strong>🎯 ARF Value:</strong> Reduces MTTR from {total_manual:.0f} to {total_arf:.0f} minutes<br>
-                    <strong>💎 Mode:</strong> {boundary_text} autonomous execution<br>
-                    <strong>📈 Impact:</strong> {percent_faster:.0f}% faster resolution
-                </div>
-            </div>
-        </div>
-        """
-    
-    def _create_timeline_segments(self, phases: List[str], manual_times: List[float], 
-                                 arf_times: List[float], boundary_color: str) -> str:
-        """Create timeline segments HTML"""
-        segments_html = ""
-        total_width = 0
-        
-        for i, (phase, manual_time, arf_time) in enumerate(zip(phases, manual_times, arf_times)):
-            # Calculate widths as percentages
-            manual_width = (manual_time / 125) * 100  # 125 = sum of all times
-            arf_width = (arf_time / 125) * 100
-            
-            segments_html += f"""
-            <div style="position: absolute; left: {total_width}%; width: {manual_width}%; 
-                       top: 10px; text-align: center;">
-                <div style="height: 20px; background: #ef4444; border-radius: 4px; margin-bottom: 5px;"></div>
-                <div style="font-size: 11px; color: #64748b;">{phase}<br>{manual_time:.0f}m</div>
-            </div>
-            
-            <div style="position: absolute; left: {total_width}%; width: {arf_width}%; 
-                       top: 35px; text-align: center;">
-                <div style="height: 20px; background: {boundary_color}; border-radius: 4px; margin-bottom: 5px;"></div>
-                <div style="font-size: 11px; color: #475569; font-weight: 500;">{arf_time:.0f}m</div>
-            </div>
-            """
-            
-            total_width += manual_width
-        
-        return segments_html
-    
-    def _get_severity_color(self, severity: str) -> str:
-        """Get color for severity level"""
-        color_map = {
-            "critical": self.color_palette["danger"],
-            "high": self.color_palette["warning"],
-            "medium": self.color_palette["info"],
-            "low": self.color_palette["success"]
-        }
-        return color_map.get(severity.lower(), self.color_palette["info"])
-    
-    # Keep other methods from original file but add boundary parameters
-    def create_agent_performance_chart(self, is_real_arf: bool = True) -> Any:
-        """Create agent performance comparison chart"""
-        if not PLOTLY_AVAILABLE:
-            # HTML fallback
-            boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-            boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-            
-            agents = ["Detection", "Recall", "Decision"]
-            accuracy = [98.7, 92.0, 94.0]
-            speed = [45, 30, 60]
-            
-            rows = ""
-            for agent, acc, spd in zip(agents, accuracy, speed):
-                rows += f"""
-                <tr>
-                    <td style="padding: 8px; border-bottom: 1px solid #e2e8f0;">
-                        <div style="font-weight: 600; color: #1e293b;">{agent}</div>
-                    </td>
-                    <td style="padding: 8px; border-bottom: 1px solid #e2e8f0; text-align: center;">
-                        <div style="font-weight: 700; color: #10b981;">{acc}%</div>
-                    </td>
-                    <td style="padding: 8px; border-bottom: 1px solid #e2e8f0; text-align: center;">
-                        <div style="font-weight: 700; color: {boundary_color};">{spd}s</div>
-                    </td>
-                </tr>
-                """
-            
-            return f"""
-            <div style="border: 2px solid {boundary_color}; border-radius: 16px; padding: 20px; 
-                       background: white; box-shadow: 0 4px 12px rgba(0,0,0,0.05);">
-                <div style="position: absolute; top: 15px; right: 15px; padding: 4px 10px; 
-                           background: {boundary_color}; color: white; border-radius: 15px; 
-                           font-size: 11px; font-weight: bold; display: flex; align-items: center; gap: 5px;">
-                    🤖 {boundary_text}
-                </div>
-                
-                <h4 style="margin: 0 0 15px 0; color: #1e293b; font-size: 16px; font-weight: 600;">
-                    🤖 Agent Performance
-                </h4>
-                
-                <table style="width: 100%; border-collapse: collapse;">
-                    <thead>
-                        <tr>
-                            <th style="padding: 8px; text-align: left; color: #64748b; font-size: 13px; border-bottom: 2px solid #e2e8f0;">Agent</th>
-                            <th style="padding: 8px; text-align: center; color: #64748b; font-size: 13px; border-bottom: 2px solid #e2e8f0;">Accuracy</th>
-                            <th style="padding: 8px; text-align: center; color: #64748b; font-size=13px; border-bottom: 2px solid #e2e8f0;">Speed</th>
-                        </tr>
-                    </thead>
-                    <tbody>
-                        {rows}
-                    </tbody>
-                </table>
-                
-                <div style="margin-top: 15px; padding: 10px; background: #f8fafc; border-radius: 8px;">
-                    <div style="font-size: 12px; color: #64748b; line-height: 1.5;">
-                        <strong>Mode:</strong> {boundary_text} v3.3.7 • 
-                        <strong>Avg Accuracy:</strong> {(sum(accuracy)/len(accuracy)):.1f}% • 
-                        <strong>Avg Speed:</strong> {(sum(speed)/len(speed)):.0f}s
-                    </div>
-                </div>
-            </div>
-            """
-        
-        # Original Plotly implementation with boundary additions
-        try:
-            agents = ["Detection", "Recall", "Decision"]
-            accuracy = [98.7, 92.0, 94.0]
-            speed = [45, 30, 60]  # seconds
-            confidence = [99.8, 92.0, 94.0]
-            
-            boundary_color = self.color_palette["real_arf"] if is_real_arf else self.color_palette["simulated"]
-            boundary_text = "REAL ARF" if is_real_arf else "SIMULATED"
-            
-            fig = go.Figure(data=[
-                go.Bar(name='Accuracy (%)', x=agents, y=accuracy, 
-                       marker_color=self.color_palette["primary"]),
-                go.Bar(name='Speed (seconds)', x=agents, y=speed,
-                       marker_color=boundary_color),
-                go.Bar(name='Confidence (%)', x=agents, y=confidence,
-                       marker_color=self.color_palette["info"])
-            ])
-            
-            # Add boundary annotation
-            fig.add_annotation(
-                x=0.98, y=0.98,
-                xref="paper", yref="paper",
-                text=f"🤖 {boundary_text}",
-                showarrow=False,
-                font=dict(size=12, color=boundary_color),
-                bgcolor="white",
-                bordercolor=boundary_color,
-                borderwidth=2,
-                borderpad=4
-            )
-            
-            fig.update_layout(
-                title=f"🤖 Agent Performance Metrics<br>"
-                     f"<span style='font-size: 12px; color: #64748b'>{boundary_text} v3.3.7</span>",
-                barmode='group',
-                height=400,
-                plot_bgcolor='rgba(0,0,0,0)',
-                paper_bgcolor='rgba(0,0,0,0)',
-                legend=dict(
-                    orientation="h",
-                    yanchor="bottom",
-                    y=1.02,
-                    xanchor="right",
-                    x=1
-                )
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Agent performance chart creation failed: {e}")
-            # Return HTML fallback
-            return self.create_agent_performance_chart.__wrapped__(self, is_real_arf)