Update app.py

app.py

@@ -1,17 +1,18 @@
 """
-🚀 ARF Investor Demo - COMPLETE STANDALONE VERSION
-No module dependencies - Everything in one file
-Works on Hugging Face Spaces
+🚀 ARF Ultimate Investor Demo v3.8.0 - ENTERPRISE EDITION
+With Audit Trail, Incident History, Memory Graph, and Enterprise Features
 """
 
 import logging
 import datetime
 import random
 import uuid
-from typing import Dict, List, Optional, Any
+import json
+import tempfile
+from typing import Dict, List, Optional, Any, Tuple
+from collections import deque
 import gradio as gr
 import plotly.graph_objects as go
-import plotly.express as px
 import pandas as pd
 import numpy as np
 from plotly.subplots import make_subplots
@@ -24,27 +25,22 @@ try:
     )
     from agentic_reliability_framework.arf_core.engine.simple_mcp_client import OSSMCPClient
     ARF_OSS_AVAILABLE = True
-    logger = logging.getLogger(__name__)
-    logger.info("✅ ARF OSS v3.3.6 successfully imported")
-except ImportError as e:
+except ImportError:
     ARF_OSS_AVAILABLE = False
-    logger = logging.getLogger(__name__)
-    logger.warning(f"⚠️ ARF OSS not available: {e}. Running in simulation mode.")
-    
-    # Mock classes
+    # 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):
+        def to_dict(self) -> Dict[str, Any]:
             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):
+    def create_scale_out_intent(resource_type: str, scale_factor: float = 2.0) -> HealingIntent:
         return HealingIntent(
             intent_type="scale_out",
             parameters={
@@ -55,7 +51,7 @@ except ImportError as e:
         )
     
     class OSSMCPClient:
-        def analyze_incident(self, metrics: Dict, pattern: str = "") -> Dict:
+        def analyze_incident(self, metrics: Dict, pattern: str = "") -> Dict[str, Any]:
             return {
                 "status": "analysis_complete",
                 "recommendations": [
@@ -72,21 +68,26 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ===========================================
-# DATA - Everything in one place
+# COMPREHENSIVE DATA
 # ===========================================
 
 INCIDENT_SCENARIOS = {
     "Cache Miss Storm": {
+        "description": "Redis cluster experiencing 80% cache miss rate causing database overload",
+        "severity": "CRITICAL",
         "metrics": {
             "Cache Hit Rate": "18.5% (Critical)",
-            "Database Load": "92% (Overloaded)",
+            "Database Load": "92% (Overloaded)", 
             "Response Time": "1850ms (Slow)",
-            "Affected Users": "45,000"
+            "Affected Users": "45,000",
+            "Eviction Rate": "125/sec"
         },
         "impact": {
             "Revenue Loss": "$8,500/hour",
             "Page Load Time": "+300%",
-            "Users Impacted": "45,000"
+            "Users Impacted": "45,000",
+            "SLA Violation": "Yes",
+            "Customer Sat": "-40%"
         },
         "oss_analysis": {
             "status": "✅ ARF OSS Analysis Complete",
@@ -94,535 +95,799 @@ INCIDENT_SCENARIOS = {
                 "Increase Redis cache memory allocation",
                 "Implement cache warming strategy",
                 "Optimize key patterns (TTL adjustments)",
-                "Add circuit breaker for database fallback"
+                "Add circuit breaker for database fallback",
+                "Deploy monitoring for cache hit rate trends"
             ],
             "estimated_time": "60+ minutes",
-            "engineers_needed": "2-3 SREs",
+            "engineers_needed": "2-3 SREs + 1 DBA",
             "manual_effort": "High",
-            "arf_oss": True,
-            "healing_intent_created": True
+            "total_cost": "$8,500",
+            "healing_intent": "scale_out_cache"
         },
         "enterprise_results": {
             "actions_completed": [
-                "✅ Auto-scaled Redis: 4GB → 8GB",
-                "✅ Deployed cache warming service",
-                "✅ Optimized 12 key patterns",
-                "✅ Implemented circuit breaker"
+                "✅ 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%"
+                "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"
+                "Users Impacted": "45,000 → 0",
+                "Revenue Protected": "$1,700",
+                "MTTR Improvement": "80% reduction"
             }
         }
     },
     "Database Connection Pool Exhaustion": {
+        "description": "Database connection pool exhausted causing API timeouts and user failures",
+        "severity": "HIGH",
         "metrics": {
             "Active Connections": "98/100 (Critical)",
             "API Latency": "2450ms",
             "Error Rate": "15.2%",
-            "Queue Depth": "1250"
+            "Queue Depth": "1250",
+            "Connection Wait": "45s"
         },
         "impact": {
             "Revenue Loss": "$4,200/hour",
-            "Affected Services": "API Gateway, User Service",
-            "SLA Violation": "Yes"
+            "Affected Services": "API Gateway, User Service, Payment",
+            "SLA Violation": "Yes",
+            "Partner Impact": "3 external APIs"
         }
     },
     "Memory Leak in Production": {
+        "description": "Java service memory leak causing gradual performance degradation",
+        "severity": "HIGH",
         "metrics": {
             "Memory Usage": "96% (Critical)",
             "GC Pause Time": "4500ms",
             "Error Rate": "28.5%",
-            "Restart Frequency": "12/hour"
+            "Restart Frequency": "12/hour",
+            "Heap Fragmentation": "42%"
         },
         "impact": {
             "Revenue Loss": "$5,500/hour",
             "Session Loss": "8,500 users",
-            "Customer Impact": "High"
+            "Customer Impact": "High",
+            "Support Tickets": "+300%"
+        }
+    },
+    "API Rate Limit Exceeded": {
+        "description": "Global API rate limit exceeded causing 429 errors for external clients",
+        "severity": "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"
+        }
+    },
+    "Microservice Cascading Failure": {
+        "description": "Order service failure causing cascading failures in dependent services",
+        "severity": "CRITICAL",
+        "metrics": {
+            "Order Failure Rate": "68.2%",
+            "Circuit Breakers Open": "4",
+            "Retry Storm Intensity": "425",
+            "Error Propagation": "85%",
+            "System Stability": "15/100"
+        },
+        "impact": {
+            "Revenue Loss": "$25,000/hour",
+            "Abandoned Carts": "12,500",
+            "Affected Users": "75,000",
+            "Brand Damage": "High"
         }
     }
 }
 
 # ===========================================
-# VISUALIZATION FUNCTIONS
+# AUDIT TRAIL & HISTORY MANAGEMENT
 # ===========================================
 
-def create_timeline_visualization():
-    """Create interactive timeline"""
-    fig = go.Figure()
-    
-    events = [
-        {"time": "T-5m", "event": "📉 Cache hit rate drops", "type": "problem"},
-        {"time": "T-3m", "event": "🤖 ARF detects pattern", "type": "detection"},
-        {"time": "T-2m", "event": "🧠 Analysis complete", "type": "analysis"},
-        {"time": "T-1m", "event": "⚡ Healing executed", "type": "action"},
-        {"time": "Now", "event": "✅ System recovered", "type": "recovery"}
-    ]
-    
-    colors = {"problem": "red", "detection": "blue", "analysis": "purple", 
-              "action": "green", "recovery": "lightgreen"}
-    
-    for event in events:
-        fig.add_trace(go.Scatter(
-            x=[event["time"]],
-            y=[1],
-            mode='markers+text',
-            marker=dict(size=15, color=colors[event["type"]], symbol='circle'),
-            text=[event["event"]],
-            textposition="top center",
-            name=event["type"].capitalize()
-        ))
-    
-    fig.update_layout(
-        title="<b>Incident Timeline</b>",
-        height=400,
-        showlegend=True,
-        paper_bgcolor='rgba(0,0,0,0)',
-        plot_bgcolor='rgba(0,0,0,0)',
-        yaxis=dict(showticklabels=False, range=[0.5, 1.5])
-    )
-    
-    return fig
-
-def create_business_dashboard():
-    """Create executive dashboard"""
-    fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=('Cost Impact', 'Team Time', 'MTTR Comparison', 'ROI'),
-        vertical_spacing=0.15
-    )
+class AuditTrailManager:
+    """Manage audit trail and execution history"""
     
-    # 1. Cost Impact
-    categories = ['Without ARF', 'With ARF Enterprise', 'Savings']
-    values = [2.96, 1.0, 1.96]
+    def __init__(self) -> None:
+        self.execution_history = deque(maxlen=50)
+        self.incident_history = deque(maxlen=100)
+        self._initialize_sample_data()
     
-    fig.add_trace(
-        go.Bar(x=categories, y=values, marker_color=['#FF6B6B', '#4ECDC4', '#45B7D1']),
-        row=1, col=1
-    )
+    def _initialize_sample_data(self) -> None:
+        """Initialize with sample historical data"""
+        base_time = datetime.datetime.now() - datetime.timedelta(hours=2)
+        
+        # Sample execution history
+        sample_executions = [
+            self._create_execution_entry(
+                base_time - datetime.timedelta(minutes=90),
+                "Cache Miss Storm", 4, 7200, "✅ Executed", "Auto-scaled cache"
+            ),
+            self._create_execution_entry(
+                base_time - datetime.timedelta(minutes=75),
+                "Memory Leak", 3, 5200, "✅ Executed", "Fixed memory leak"
+            ),
+            self._create_execution_entry(
+                base_time - datetime.timedelta(minutes=60),
+                "API Rate Limit", 4, 2800, "✅ Executed", "Increased rate limits"
+            ),
+            self._create_execution_entry(
+                base_time - datetime.timedelta(minutes=45),
+                "DB Connection Pool", 4, 3800, "✅ Executed", "Scaled connection pool"
+            ),
+            self._create_execution_entry(
+                base_time - datetime.timedelta(minutes=30),
+                "Cascading Failure", 5, 12500, "✅ Executed", "Isolated services"
+            ),
+            self._create_execution_entry(
+                base_time - datetime.timedelta(minutes=15),
+                "Cache Miss Storm", 4, 7200, "✅ Executed", "Optimized cache"
+            )
+        ]
+        
+        for execution in sample_executions:
+            self.execution_history.append(execution)
+        
+        # Sample incident history
+        services = ["API Gateway", "Database", "Cache", "Auth Service", "Payment Service", 
+                   "Order Service", "User Service", "Session Service"]
+        
+        for _ in range(25):
+            incident_time = base_time - datetime.timedelta(minutes=random.randint(5, 120))
+            self.incident_history.append({
+                "timestamp": incident_time,
+                "time_str": incident_time.strftime("%H:%M"),
+                "service": random.choice(services),
+                "type": random.choice(list(INCIDENT_SCENARIOS.keys())),
+                "severity": random.randint(1, 3),
+                "description": f"{random.choice(['High latency', 'Connection failed', 'Memory spike', 'Timeout'])} on {random.choice(services)}",
+                "id": str(uuid.uuid4())[:8]
+            })
     
-    # 2. Team Time
-    activities = ['Firefighting', 'Innovation', 'Strategic']
-    before = [60, 20, 20]
-    after = [10, 60, 30]
+    def _create_execution_entry(self, timestamp: datetime.datetime, scenario: str, 
+                               actions: int, savings: int, status: str, details: str) -> Dict[str, Any]:
+        """Create an execution history entry"""
+        return {
+            "timestamp": timestamp,
+            "time_str": timestamp.strftime("%H:%M"),
+            "scenario": scenario,
+            "actions": str(actions),
+            "savings": f"${savings:,}",
+            "status": status,
+            "details": details,
+            "id": str(uuid.uuid4())[:8]
+        }
     
-    fig.add_trace(go.Bar(x=activities, y=before, name='Before', marker_color='#FF6B6B'), row=1, col=2)
-    fig.add_trace(go.Bar(x=activities, y=after, name='After', marker_color='#4ECDC4'), row=1, col=2)
+    def add_execution(self, scenario: str, actions: List[str], 
+                     savings: int, approval_required: bool, details: str = "") -> Dict[str, Any]:
+        """Add new execution to history"""
+        entry = self._create_execution_entry(
+            datetime.datetime.now(),
+            scenario,
+            len(actions),
+            savings,
+            "✅ Approved & Executed" if approval_required else "✅ Auto-Executed",
+            details
+        )
+        self.execution_history.appendleft(entry)  # Newest first
+        return entry
     
-    # 3. MTTR Comparison
-    mttr_methods = ['Manual', 'Traditional', 'ARF OSS', 'ARF Enterprise']
-    mttr_times = [120, 45, 25, 8]
+    def add_incident(self, scenario_name: str, metrics: Dict) -> Dict[str, Any]:
+        """Add incident to history"""
+        severity = 2 if "MEDIUM" in INCIDENT_SCENARIOS.get(scenario_name, {}).get("severity", "") else 3
+        entry = {
+            "timestamp": datetime.datetime.now(),
+            "time_str": datetime.datetime.now().strftime("%H:%M"),
+            "service": "Demo System",
+            "type": scenario_name,
+            "severity": severity,
+            "description": f"Demo incident: {scenario_name}",
+            "id": str(uuid.uuid4())[:8]
+        }
+        self.incident_history.appendleft(entry)
+        return entry
     
-    fig.add_trace(
-        go.Bar(x=mttr_methods, y=mttr_times, marker_color=['#FF6B6B', '#FFE66D', '#45B7D1', '#4ECDC4']),
-        row=2, col=1
-    )
+    def get_execution_history_table(self, limit: int = 10) -> List[List[str]]:
+        """Get execution history for table display"""
+        return [
+            [entry["time_str"], entry["scenario"], entry["actions"], 
+             entry["status"], entry["savings"], entry["details"]]
+            for entry in list(self.execution_history)[:limit]
+        ]
     
-    # 4. ROI Gauge
-    fig.add_trace(
-        go.Indicator(
-            mode="gauge+number",
-            value=5.2,
-            title={'text': "ROI Multiplier"},
-            gauge={
-                'axis': {'range': [0, 10]},
-                'bar': {'color': "#4ECDC4"},
-                'steps': [
-                    {'range': [0, 2], 'color': "lightgray"},
-                    {'range': [2, 4], 'color': "gray"},
-                    {'range': [4, 6], 'color': "lightgreen"},
-                    {'range': [6, 10], 'color': "green"}
-                ]
-            }
-        ),
-        row=2, col=2
-    )
+    def get_incident_history_table(self, limit: int = 15) -> List[List[str]]:
+        """Get incident history for table display"""
+        return [
+            [entry["time_str"], entry["service"], entry["type"], 
+             f"{entry['severity']}/3", entry["description"]]
+            for entry in list(self.incident_history)[:limit]
+        ]
     
-    fig.update_layout(
-        height=700,
-        showlegend=True,
-        paper_bgcolor='rgba(0,0,0,0)',
-        plot_bgcolor='rgba(0,0,0,0)',
-        title_text="<b>Executive Business Dashboard</b>"
-    )
+    def clear_history(self) -> Tuple[List[List[str]], List[List[str]]]:
+        """Clear all history"""
+        self.execution_history.clear()
+        self.incident_history.clear()
+        self._initialize_sample_data()  # Restore sample data
+        return self.get_execution_history_table(), self.get_incident_history_table()
     
-    return fig
+    def export_audit_trail(self) -> str:
+        """Export audit trail as JSON"""
+        total_savings = 0
+        for e in self.execution_history:
+            if "$" in e["savings"]:
+                try:
+                    total_savings += int(e["savings"].replace("$", "").replace(",", ""))
+                except ValueError:
+                    continue
+        
+        return json.dumps({
+            "executions": list(self.execution_history),
+            "incidents": list(self.incident_history),
+            "exported_at": datetime.datetime.now().isoformat(),
+            "total_executions": len(self.execution_history),
+            "total_incidents": len(self.incident_history),
+            "total_savings": total_savings
+        }, indent=2, default=str)
 
 # ===========================================
-# BUSINESS LOGIC
+# ENHANCED VISUALIZATION ENGINE
 # ===========================================
 
-def run_oss_analysis(scenario_name: str):
-    """Run OSS analysis"""
-    scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-    analysis = scenario.get("oss_analysis", {})
-    
-    if not analysis:
-        analysis = {
-            "status": "✅ Analysis Complete",
-            "recommendations": [
-                "Increase resource allocation",
-                "Implement monitoring",
-                "Add circuit breakers",
-                "Optimize configuration"
-            ],
-            "estimated_time": "45-60 minutes",
-            "engineers_needed": "2-3",
-            "manual_effort": "Required",
-            "arf_oss": ARF_OSS_AVAILABLE
-        }
-    
-    # Add ARF context
-    analysis["arf_context"] = {
-        "oss_available": ARF_OSS_AVAILABLE,
-        "version": "3.3.6",
-        "mode": "advisory_only",
-        "healing_intent": "created" if ARF_OSS_AVAILABLE else "simulated"
-    }
-    
-    return analysis
-
-def execute_enterprise_healing(scenario_name: str, approval_required: bool):
-    """Execute enterprise healing"""
-    scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-    results = scenario.get("enterprise_results", {})
+class EnhancedVisualizationEngine:
+    """Enhanced visualization engine with memory graph support"""
     
-    if not results:
-        results = {
-            "status": "✅ Auto-Executed" if not approval_required else "✅ Approved and Executed",
-            "actions_completed": [
-                "✅ Auto-scaled resources",
-                "✅ Implemented optimization",
-                "✅ Deployed monitoring",
-                "✅ Validated recovery"
-            ],
-            "metrics_improvement": {
-                "Performance": "Improved",
-                "Recovery": "Complete"
-            },
-            "business_impact": {
-                "Cost Saved": f"${random.randint(2000, 8000):,}",
-                "Time Saved": f"{random.randint(30, 60)} min → {random.randint(5, 15)} min"
-            }
+    @staticmethod
+    def create_incident_timeline() -> go.Figure:
+        """Create interactive incident timeline"""
+        fig = go.Figure()
+        
+        # Create timeline events
+        now = datetime.datetime.now()
+        events = [
+            {"time": now - datetime.timedelta(minutes=25), "event": "📉 Cache hit rate drops to 18.5%", "type": "problem"},
+            {"time": now - datetime.timedelta(minutes=22), "event": "⚠️ Alert: Database load hits 92%", "type": "alert"},
+            {"time": now - datetime.timedelta(minutes=20), "event": "🤖 ARF detects pattern", "type": "detection"},
+            {"time": now - datetime.timedelta(minutes=18), "event": "🧠 Analysis: Cache Miss Storm identified", "type": "analysis"},
+            {"time": now - datetime.timedelta(minutes=15), "event": "⚡ Healing actions executed", "type": "action"},
+            {"time": now - datetime.timedelta(minutes=12), "event": "✅ Cache hit rate recovers to 72%", "type": "recovery"},
+            {"time": now - datetime.timedelta(minutes=10), "event": "📊 System stabilized", "type": "stable"}
+        ]
+        
+        color_map = {
+            "problem": "red", "alert": "orange", "detection": "blue",
+            "analysis": "purple", "action": "green", "recovery": "lightgreen",
+            "stable": "darkgreen"
         }
+        
+        for event in events:
+            fig.add_trace(go.Scatter(
+                x=[event["time"]],
+                y=[1],
+                mode='markers+text',
+                marker=dict(
+                    size=15,
+                    color=color_map[event["type"]],
+                    symbol='circle' if event["type"] in ['problem', 'alert'] else 'diamond',
+                    line=dict(width=2, color='white')
+                ),
+                text=[event["event"]],
+                textposition="top center",
+                name=event["type"].capitalize(),
+                hovertemplate="<b>%{text}</b><br>%{x|%H:%M:%S}<extra></extra>"
+            ))
+        
+        fig.update_layout(
+            title="<b>Incident Timeline - Cache Miss Storm Resolution</b>",
+            xaxis_title="Time →",
+            yaxis_title="Event Type",
+            height=450,
+            showlegend=True,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            hovermode='closest',
+            xaxis=dict(
+                tickformat='%H:%M',
+                gridcolor='rgba(200,200,200,0.2)'
+            ),
+            yaxis=dict(
+                showticklabels=False,
+                gridcolor='rgba(200,200,200,0.1)'
+            )
+        )
+        
+        return fig
     
-    # Add approval info
-    if approval_required:
-        approval_html = f"""
-        <div style='padding: 15px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #007bff; margin: 10px 0;'>
-        <h4 style='margin: 0 0 10px 0;'>🛡️ Approval Required</h4>
-        <p><b>Action:</b> Scale resources for {scenario_name}</p>
-        <p><b>Risk:</b> Low (auto-rollback available)</p>
-        <p><b>Status:</b> ✅ <span style='color: green;'>Approved & Executed</span></p>
-        </div>
-        """
-    else:
-        approval_html = f"""
-        <div style='padding: 15px; background: #e8f5e8; border-radius: 8px; border-left: 4px solid #28a745; margin: 10px 0;'>
-        <h4 style='margin: 0 0 10px 0;'>⚡ Auto-Executed</h4>
-        <p><b>Action:</b> Autonomous healing for {scenario_name}</p>
-        <p><b>Mode:</b> Fully autonomous (guardrails active)</p>
-        <p><b>Status:</b> ✅ <span style='color: green;'>Successfully completed</span></p>
-        </div>
-        """
+    @staticmethod
+    def create_business_dashboard() -> go.Figure:
+        """Create executive business dashboard"""
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('Annual Cost Impact', 'Team Capacity Shift',
+                          'MTTR Comparison', 'ROI Analysis'),
+            vertical_spacing=0.15,
+            horizontal_spacing=0.15
+        )
+        
+        # 1. Cost Impact
+        categories = ['Without ARF', 'With ARF Enterprise', 'Net Savings']
+        values = [2960000, 1000000, 1960000]
+        
+        fig.add_trace(
+            go.Bar(
+                x=categories,
+                y=values,
+                marker_color=['#FF6B6B', '#4ECDC4', '#45B7D1'],
+                text=[f'${v/1000000:.1f}M' for v in values],
+                textposition='auto',
+                name='Cost Impact'
+            ),
+            row=1, col=1
+        )
+        
+        # 2. Team Capacity Shift
+        labels = ['Firefighting', 'Innovation', 'Strategic Work']
+        before = [60, 20, 20]
+        after = [10, 60, 30]
+        
+        fig.add_trace(
+            go.Bar(
+                x=labels,
+                y=before,
+                name='Before ARF',
+                marker_color='#FF6B6B'
+            ),
+            row=1, col=2
+        )
+        
+        fig.add_trace(
+            go.Bar(
+                x=labels,
+                y=after,
+                name='After ARF Enterprise',
+                marker_color='#4ECDC4'
+            ),
+            row=1, col=2
+        )
+        
+        # 3. MTTR Comparison
+        mttr_categories = ['Manual', 'Traditional', 'ARF OSS', 'ARF Enterprise']
+        mttr_values = [120, 45, 25, 8]
+        
+        fig.add_trace(
+            go.Bar(
+                x=mttr_categories,
+                y=mttr_values,
+                marker_color=['#FF6B6B', '#FFE66D', '#45B7D1', '#4ECDC4'],
+                text=[f'{v} min' for v in mttr_values],
+                textposition='auto',
+                name='MTTR'
+            ),
+            row=2, col=1
+        )
+        
+        # 4. ROI Gauge
+        fig.add_trace(
+            go.Indicator(
+                mode="gauge+number+delta",
+                value=5.2,
+                title={'text': "ROI Multiplier"},
+                delta={'reference': 1.0, 'increasing': {'color': "green"}},
+                gauge={
+                    'axis': {'range': [0, 10], 'tickwidth': 1},
+                    'bar': {'color': "#4ECDC4"},
+                    'steps': [
+                        {'range': [0, 2], 'color': "lightgray"},
+                        {'range': [2, 4], 'color': "gray"},
+                        {'range': [4, 6], 'color': "lightgreen"},
+                        {'range': [6, 10], 'color': "green"}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': 5.2
+                    }
+                }
+            ),
+            row=2, col=2
+        )
+        
+        fig.update_layout(
+            height=700,
+            showlegend=True,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            title_text="<b>Executive Business Dashboard</b>",
+            barmode='group'
+        )
+        
+        return fig
     
-    # Add enterprise context
-    results["enterprise_context"] = {
-        "approval_required": approval_required,
-        "compliance_mode": "strict",
-        "audit_trail": "created",
-        "learning_applied": True,
-        "roi_measured": True
-    }
+    @staticmethod
+    def create_execution_history_chart(audit_manager: AuditTrailManager) -> go.Figure:
+        """Create execution history visualization"""
+        executions = list(audit_manager.execution_history)[:10]  # Last 10 executions
+        
+        if not executions:
+            fig = go.Figure()
+            fig.update_layout(
+                title="No execution history yet",
+                height=400,
+                paper_bgcolor='rgba(0,0,0,0)',
+                plot_bgcolor='rgba(0,0,0,0)'
+            )
+            return fig
+        
+        # Extract data
+        scenarios = [e["scenario"] for e in executions]
+        savings = []
+        for e in executions:
+            try:
+                savings.append(int(e["savings"].replace("$", "").replace(",", "")))
+            except ValueError:
+                savings.append(0)
+        
+        fig = go.Figure(data=[
+            go.Bar(
+                x=scenarios,
+                y=savings,
+                marker_color='#4ECDC4',
+                text=[f'${s:,.0f}' for s in savings],
+                textposition='outside',
+                name='Cost Saved',
+                hovertemplate="<b>%{x}</b><br>Savings: %{text}<extra></extra>"
+            )
+        ])
+        
+        fig.update_layout(
+            title="<b>Execution History - Cost Savings</b>",
+            xaxis_title="Scenario",
+            yaxis_title="Cost Saved ($)",
+            height=500,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            showlegend=False
+        )
+        
+        return fig
     
-    return approval_html, {"approval_required": approval_required, "compliance_mode": "strict"}, results
-
-def calculate_roi(monthly_incidents: int, avg_impact: int, team_size: int):
-    """Calculate ROI"""
-    try:
-        annual_impact = monthly_incidents * 12 * avg_impact
-        team_cost = team_size * 150000
-        savings = annual_impact * 0.82
-        
-        roi_multiplier = savings / team_cost if team_cost > 0 else 0
-        
-        if roi_multiplier >= 5.0:
-            recommendation = "🚀 Excellent fit for ARF Enterprise"
-        elif roi_multiplier >= 2.0:
-            recommendation = "✅ Good ROI with ARF Enterprise"
-        elif roi_multiplier >= 1.0:
-            recommendation = "⚠️ Consider ARF OSS edition first"
+    @staticmethod
+    def create_memory_graph(audit_manager: AuditTrailManager, graph_type: str = "Force Directed", 
+                           show_weights: bool = True, auto_layout: bool = True) -> go.Figure:
+        """Create interactive memory graph visualization"""
+        fig = go.Figure()
+        
+        # Get incidents from history
+        incidents = list(audit_manager.incident_history)[:20]  # Last 20 incidents
+        
+        if not incidents:
+            # Create sample graph
+            nodes = [
+                {"id": "Incident_1", "label": "Cache Miss", "type": "incident", "size": 20},
+                {"id": "Action_1", "label": "Scale Cache", "type": "action", "size": 15},
+                {"id": "Outcome_1", "label": "Resolved", "type": "outcome", "size": 15},
+                {"id": "Component_1", "label": "Redis", "type": "component", "size": 18},
+            ]
+            
+            edges = [
+                {"source": "Incident_1", "target": "Action_1", "weight": 0.9, "label": "resolved_by"},
+                {"source": "Action_1", "target": "Outcome_1", "weight": 1.0, "label": "leads_to"},
+                {"source": "Incident_1", "target": "Component_1", "weight": 0.8, "label": "affects"},
+            ]
         else:
-            recommendation = "🆓 Start with ARF OSS (free)"
+            # Create nodes from actual incidents
+            nodes = []
+            edges = []
+            
+            for i, incident in enumerate(incidents):
+                node_id = f"Incident_{i}"
+                nodes.append({
+                    "id": node_id,
+                    "label": incident["type"][:20],
+                    "type": "incident",
+                    "size": 15 + (incident.get("severity", 2) * 5),
+                    "severity": incident.get("severity", 2)
+                })
+                
+                # Create edges to previous incidents
+                if i > 0:
+                    prev_id = f"Incident_{i-1}"
+                    edges.append({
+                        "source": prev_id,
+                        "target": node_id,
+                        "weight": 0.7,
+                        "label": "related_to"
+                    })
         
-        return {
-            "analysis": {
-                "your_annual_impact": f"${annual_impact:,.0f}",
-                "your_team_cost": f"${team_cost:,.0f}",
-                "potential_savings": f"${savings:,.0f}",
-                "your_roi_multiplier": f"{roi_multiplier:.1f}×",
-                "vs_industry_average": "5.2× average ROI",
-                "recommendation": recommendation,
-                "payback_period": f"{(team_cost / (savings / 12)):.1f} months" if savings > 0 else "N/A"
-            }
+        # Color mapping
+        color_map = {
+            "incident": "#FF6B6B",
+            "action": "#4ECDC4",
+            "outcome": "#45B7D1",
+            "component": "#96CEB4"
         }
-    except Exception as e:
-        return {"error": f"Calculation error: {str(e)}"}
-
-# ===========================================
-# MAIN INTERFACE
-# ===========================================
-
-def create_interface():
-    """Create the Gradio interface"""
-    
-    custom_css = """
-    .gradio-container { max-width: 1200px; margin: auto; }
-    h1, h2, h3 { color: #1a365d !important; }
-    """
-    
-    with gr.Blocks(
-        title="🚀 ARF Investor Demo v3.6.0",
-        theme=gr.themes.Soft(),
-        css=custom_css
-    ) as demo:
-        
-        # ============ HEADER ============
-        arf_status = "✅ ARF OSS v3.3.6" if ARF_OSS_AVAILABLE else "⚠️ Simulation Mode"
-        
-        gr.Markdown(f"""
-        # 🚀 Agentic Reliability Framework - Investor Demo v3.6.0
-        ## From Cost Center to Profit Engine: 5.2× ROI with Autonomous Reliability
-        
-        <div style='color: #666; font-size: 16px; margin-top: 10px;'>
-        {arf_status} | Experience: <b>OSS (Advisory)</b> ↔ <b>Enterprise (Autonomous)</b>
-        </div>
-        """)
-        
-        # ============ MAIN TABS ============
-        with gr.Tabs():
-            
-            # TAB 1: LIVE INCIDENT DEMO
-            with gr.TabItem("🔥 Live Incident Demo"):
-                with gr.Row():
-                    # Left Panel
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 🎬 Incident Scenario")
-                        scenario_dropdown = gr.Dropdown(
-                            choices=list(INCIDENT_SCENARIOS.keys()),
-                            value="Cache Miss Storm",
-                            label="Select critical incident:"
-                        )
-                        
-                        gr.Markdown("### 📊 Current Crisis Metrics")
-                        metrics_display = gr.JSON(
-                            value=INCIDENT_SCENARIOS["Cache Miss Storm"]["metrics"]
-                        )
-                        
-                        gr.Markdown("### 💰 Business Impact")
-                        impact_display = gr.JSON(
-                            value=INCIDENT_SCENARIOS["Cache Miss Storm"]["impact"]
-                        )
-                    
-                    # Right Panel
-                    with gr.Column(scale=2):
-                        # Visualization
-                        gr.Markdown("### 📈 Incident Timeline")
-                        timeline_output = gr.Plot()
-                        
-                        # Action Buttons
-                        with gr.Row():
-                            oss_btn = gr.Button("🆓 Run OSS Analysis", variant="secondary")
-                            enterprise_btn = gr.Button("🚀 Execute Enterprise Healing", variant="primary")
-                        
-                        # Approval Toggle
-                        approval_toggle = gr.Checkbox(
-                            label="🔐 Require Manual Approval",
-                            value=True,
-                            info="Toggle to show approval workflow vs auto-execution"
-                        )
-                        
-                        # Approval Display
-                        approval_display = gr.HTML(
-                            value="<div style='padding: 10px; background: #f8f9fa; border-radius: 5px;'>Approval status will appear here</div>"
-                        )
-                        
-                        # Configuration
-                        config_display = gr.JSON(
-                            label="⚙️ Enterprise Configuration",
-                            value={"approval_required": True, "compliance_mode": "strict"}
-                        )
-                        
-                        # Results
-                        results_display = gr.JSON(
-                            label="🎯 Execution Results",
-                            value={"status": "Ready for execution..."}
-                        )
+        
+        # Add nodes
+        node_x = []
+        node_y = []
+        node_text = []
+        node_color = []
+        node_size = []
+        
+        for i, node in enumerate(nodes):
+            # Simple layout - could be enhanced with networkx
+            angle = 2 * np.pi * i / len(nodes)
+            radius = 1.0
             
-            # TAB 2: BUSINESS IMPACT & ROI
-            with gr.TabItem("💰 Business Impact & ROI"):
-                with gr.Column():
-                    # Business Dashboard
-                    gr.Markdown("### 📊 Business Health Dashboard")
-                    dashboard_output = gr.Plot()
-                    
-                    # ROI Calculator
-                    gr.Markdown("### 🧮 Interactive ROI Calculator")
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            monthly_slider = gr.Slider(
-                                1, 100, value=15, step=1,
-                                label="Monthly incidents"
-                            )
-                            impact_slider = gr.Slider(
-                                1000, 50000, value=8500, step=500,
-                                label="Avg incident impact ($)"
-                            )
-                            team_slider = gr.Slider(
-                                1, 20, value=5, step=1,
-                                label="Reliability team size"
-                            )
-                            calculate_btn = gr.Button("Calculate My ROI", variant="primary")
-                        
-                        with gr.Column(scale=2):
-                            roi_output = gr.JSON(
-                                label="Your ROI Analysis",
-                                value={"analysis": "Adjust sliders and click 'Calculate My ROI'"}
-                            )
-                    
-                    # Capability Comparison
-                    gr.Markdown("### 📋 Capability Comparison")
-                    with gr.Row():
-                        with gr.Column():
-                            gr.Markdown("""
-                            **OSS Edition (Free)**
-                            - Advisory recommendations only
-                            - Manual implementation required
-                            - No auto-healing
-                            - Community support
-                            - No ROI measurement
-                            """)
-                        with gr.Column():
-                            gr.Markdown("""
-                            **Enterprise Edition**
-                            - Autonomous execution
-                            - 81.7% auto-heal rate
-                            - Full audit trails & compliance
-                            - 24/7 enterprise support
-                            - 5.2× average ROI
-                            - 2-3 month payback
-                            """)
-        
-        # ============ FOOTER ============
-        gr.Markdown("---")
-        with gr.Row():
-            with gr.Column(scale=2):
-                gr.Markdown("""
-                **📞 Contact & Demo**  
-                📧 petter2025us@outlook.com  
-                🌐 [https://arf.dev](https://arf.dev)  
-                📚 [Documentation](https://docs.arf.dev)  
-                💻 [GitHub](https://github.com/petterjuan/agentic-reliability-framework)
-                """)
-            with gr.Column(scale=1):
-                gr.Markdown("""
-                **🎯 Schedule a Demo**  
-                (https://calendly.com/petter2025us/30min)
-                """)
-        
-        # ============ EVENT HANDLERS ============
-        
-        def update_scenario(scenario_name: str):
-            """Update when scenario changes"""
-            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-            return (
-                scenario.get("metrics", {}),
-                scenario.get("impact", {}),
-                create_timeline_visualization()
-            )
+            node_x.append(radius * np.cos(angle))
+            node_y.append(radius * np.sin(angle))
+            node_text.append(f"{node['label']}<br>Type: {node['type']}")
+            node_color.append(color_map.get(node["type"], "#999999"))
+            node_size.append(node.get("size", 15))
+        
+        fig.add_trace(go.Scatter(
+            x=node_x,
+            y=node_y,
+            mode='markers+text',
+            marker=dict(
+                size=node_size,
+                color=node_color,
+                line=dict(width=2, color='white')
+            ),
+            text=[node["label"] for node in nodes],
+            textposition="top center",
+            hovertext=node_text,
+            hoverinfo="text",
+            name="Nodes"
+        ))
+        
+        # Add edges
+        for edge in edges:
+            try:
+                source_idx = next(i for i, n in enumerate(nodes) if n["id"] == edge["source"])
+                target_idx = next(i for i, n in enumerate(nodes) if n["id"] == edge["target"])
+                
+                fig.add_trace(go.Scatter(
+                    x=[node_x[source_idx], node_x[target_idx], None],
+                    y=[node_y[source_idx], node_y[target_idx], None],
+                    mode='lines',
+                    line=dict(
+                        width=2 * edge.get("weight", 1.0),
+                        color='rgba(100, 100, 100, 0.5)'
+                    ),
+                    hoverinfo='none',
+                    showlegend=False
+                ))
+            except StopIteration:
+                continue
         
-        # Scenario change
-        scenario_dropdown.change(
-            update_scenario,
-            inputs=[scenario_dropdown],
-            outputs=[metrics_display, impact_display, timeline_output]
+        fig.update_layout(
+            title="<b>Incident Memory Graph</b>",
+            showlegend=True,
+            height=600,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            hovermode='closest',
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            margin=dict(l=20, r=20, t=40, b=20)
         )
         
-        # OSS Analysis
-        oss_btn.click(
-            run_oss_analysis,
-            inputs=[scenario_dropdown],
-            outputs=[results_display]
+        return fig
+    
+    @staticmethod
+    def create_pattern_analysis_chart(analysis_data: Dict[str, Any]) -> go.Figure:
+        """Create pattern analysis visualization"""
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('Incident Frequency', 'Resolution Times', 
+                          'Success Rates', 'Pattern Correlation'),
+            vertical_spacing=0.15
         )
         
-        # Enterprise Execution
-        enterprise_btn.click(
-            execute_enterprise_healing,
-            inputs=[scenario_dropdown, approval_toggle],
-            outputs=[approval_display, config_display, results_display]
+        # Sample data - in real app this would come from analysis
+        patterns = ['Cache Issues', 'DB Connections', 'Memory Leaks', 'API Limits', 'Cascading']
+        frequencies = [12, 8, 5, 7, 3]
+        resolution_times = [8.2, 15.5, 45.2, 5.1, 32.8]
+        success_rates = [92, 85, 78, 96, 65]
+        
+        # Incident Frequency
+        fig.add_trace(
+            go.Bar(x=patterns, y=frequencies, name='Frequency'),
+            row=1, col=1
         )
         
-        # Approval toggle updates config
-        approval_toggle.change(
-            lambda approval: {"approval_required": approval, "compliance_mode": "strict"},
-            inputs=[approval_toggle],
-            outputs=[config_display]
+        # Resolution Times
+        fig.add_trace(
+            go.Bar(x=patterns, y=resolution_times, name='Resolution Time (min)'),
+            row=1, col=2
         )
         
-        # ROI Calculation
-        calculate_btn.click(
-            calculate_roi,
-            inputs=[monthly_slider, impact_slider, team_slider],
-            outputs=[roi_output]
+        # Success Rates
+        fig.add_trace(
+            go.Bar(x=patterns, y=success_rates, name='Success Rate %'),
+            row=2, col=1
         )
         
-        # ============ INITIAL LOAD ============
-        def load_initial():
-            """Load initial state"""
-            return (
-                INCIDENT_SCENARIOS["Cache Miss Storm"]["metrics"],
-                INCIDENT_SCENARIOS["Cache Miss Storm"]["impact"],
-                create_timeline_visualization(),
-                create_business_dashboard()
-            )
+        # Correlation Matrix
+        corr_matrix = np.array([
+            [1.0, 0.3, 0.1, 0.2, 0.05],
+            [0.3, 1.0, 0.4, 0.1, 0.25],
+            [0.1, 0.4, 1.0, 0.05, 0.6],
+            [0.2, 0.1, 0.05, 1.0, 0.1],
+            [0.05, 0.25, 0.6, 0.1, 1.0]
+        ])
         
-        demo.load(
-            load_initial,
-            outputs=[metrics_display, impact_display, timeline_output, dashboard_output]
+        fig.add_trace(
+            go.Heatmap(z=corr_matrix, x=patterns, y=patterns),
+            row=2, col=2
         )
         
-        # ============ INSTRUCTIONS ============
-        gr.Markdown(f"""
-        <div style='margin-top: 40px; padding-top: 20px; border-top: 1px solid #e2e8f0; color: #718096; font-size: 14px;'>
-        🚀 <b>ARF Ultimate Investor Demo v3.6.0</b> | {'✅ Integrated with ARF OSS v3.3.6' if ARF_OSS_AVAILABLE else '⚠️ Running in simulation mode'}  
-        <i>From Cost Center to Profit Engine: 5.2× ROI with Autonomous Reliability</i>
-        </div>
-        """)
-    
-    return demo
+        fig.update_layout(
+            height=700,
+            showlegend=False,
+            title_text="<b>Pattern Analysis Dashboard</b>"
+        )
+        
+        return fig
 
 # ===========================================
-# MAIN
+# ENHANCED BUSINESS LOGIC
 # ===========================================
 
-if __name__ == "__main__":
-    logger.info("=" * 80)
-    logger.info("🚀 Launching ARF Investor Demo v3.6.0")
-    logger.info(f"✅ ARF OSS Available: {ARF_OSS_AVAILABLE}")
-    logger.info("✅ Standalone version - No module dependencies")
-    logger.info("=" * 80)
+class EnhancedBusinessLogic:
+    """Enhanced business logic with enterprise features"""
+    
+    def __init__(self, audit_manager: AuditTrailManager):
+        self.audit_manager = audit_manager
+        self.viz_engine = EnhancedVisualizationEngine()
+        self.license_info = {
+            "valid": True,
+            "customer_name": "Demo Enterprise Corp",
+            "customer_email": "demo@enterprise.com",
+            "tier": "ENTERPRISE",
+            "expires_at": "2024-12-31T23:59:59",
+            "features": ["autonomous_healing", "compliance", "audit_trail", "multi_cloud"],
+            "max_services": 100,
+            "max_incidents_per_month": 1000,
+            "status": "✅ Active"
+        }
+        self.mcp_mode = "approval"
+        self.learning_stats = {
+            "total_incidents": 127,
+            "resolved_automatically": 89,
+            "average_resolution_time": "8.2 min",
+            "success_rate": "92.1%",
+            "patterns_detected": 24,
+            "confidence_threshold": 0.85,
+            "memory_size": "4.7 MB",
+            "embeddings": 127,
+            "graph_nodes": 89,
+            "graph_edges": 245
+        }
+    
+    def run_oss_analysis(self, scenario_name: str) -> Dict[str, Any]:
+        """Run OSS analysis"""
+        scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
+        analysis = scenario.get("oss_analysis", {})
+        
+        if not analysis:
+            analysis = {
+                "status": "✅ Analysis Complete",
+                "recommendations": [
+                    "Increase resource allocation",
+                    "Implement monitoring",
+                    "Add circuit breakers",
+                    "Optimize configuration"
+                ],
+                "estimated_time": "45-60 minutes",
+                "engineers_needed": "2-3",
+                "manual_effort": "Required",
+                "total_cost": "$3,000 - $8,000"
+            }
+        
+        # Add ARF context
+        analysis["arf_context"] = {
+            "oss_available": ARF_OSS_AVAILABLE,
+            "version": "3.3.6",
+            "mode": "advisory_only",
+            "healing_intent": True
+        }
+        
+        # Add to incident history
+        self.audit_manager.add_incident(scenario_name, scenario.get("metrics", {}))
+        
+        return analysis
+    
+    def execute_enterprise_healing(self, scenario_name: str, approval_required: bool) -> Tuple[Any, ...]:
+        """Execute enterprise healing"""
+        scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
+        results = scenario.get("enterprise_results", {})
+        
+        # Use default results if not available
+        if not results:
+            results = {
+                "actions_completed": [
+                    "✅ Auto-scaled resources based on ARF healing intent",
+                    "✅ Implemented optimization recommendations",
+                    "✅ Deployed monitoring and alerting",
+                    "✅ Validated recovery with automated testing"
+                ],
+                "metrics_improvement": {
+                    "Performance": "Dramatically improved",
+                    "Stability": "Restored",
+                    "Recovery": "Complete"
+                },
+                "business_impact": {
+                    "Recovery Time": f"60 min → {random.randint(5, 15)} min",
+                    "Cost Saved": f"${random.randint(2000, 10000):,}",
+                    "Users Impacted": "45,000 → 0",
+                    "Revenue Protected": f"${random.randint(1000, 5000):,}"
+                }
+            }
+        
+        # Calculate savings
+        savings = 0
+        if "Cost Saved" in results["business_impact"]:
+            try:
+                savings_str = results["business_impact"]["Cost Saved"]
+                savings = int(''.join(filter(str.isdigit, savings_str)))
+            except (ValueError, TypeError):
+                savings = random.randint(2000, 10000)
+        
+        # Update status
+        if approval_required:
+            results["status"] = "✅ Approved and Executed"
+            approval_html = self._create_approval_html(scenario_name, True)
+        else:
+            results["status"] = "✅ Auto-Executed"
+            approval_html = self._create_approval_html(scenario_name, False)
+        
+        # Add to audit trail
+        details = f"{len(results['actions_completed'])} actions executed"
+        self.audit_manager.add_execution(
+            scenario_name,
+            results["actions_completed"],
+            savings,
+            approval_required,
+            details
+        )
+        
+        # Add enterprise context
+        results["enterprise_context"] = {
+            "approval_required": approval_required,
+            "compliance_mode": "strict",
+            "audit_trail": "created",
+            "learning_applied": True,
+            "roi_measured": True
+        }
+        
+        # Update visualizations
+        execution_chart = self.viz_engine.create_execution_history_chart(self.audit_manager)
+        
+        return (
+            approval_html,
+            {"approval_required": approval_required, "compliance_mode": "strict"},
+            results,
+            execution_chart,
+            self.audit_manager.get_execution_history_table(),
+            self.audit_manager.get_incident_history_table()
+        )
     
-    demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=False,
-        show_error=True
-    )
+    def _create_approval_html(self, scenario_name: str, approval_required: bool) -> str:
+