Update app.py

app.py

@@ -1,8 +1,6 @@
 """
 🚀 ARF Ultimate Investor Demo v3.8.0 - ENTERPRISE EDITION
-Main entry point with comprehensive 5-tab interface
-Uses actual ARF OSS v3.3.6 framework
-FULLY CORRECTED VERSION - Integrated with all components
+COMPLETE FIXED VERSION - All components integrated
 """
 
 import logging
@@ -12,8 +10,9 @@ import json
 import datetime
 import asyncio
 import time
+import numpy as np
 from pathlib import Path
-from typing import Dict, List, Any, Optional, Tuple, Union
+from typing import Dict, List, Any, Optional, Tuple
 
 # Configure logging
 logging.basicConfig(
@@ -29,181 +28,26 @@ logger = logging.getLogger(__name__)
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent))
 
-# ===========================================
-# ARF FRAMEWORK IMPORT - CORRECTED BASED ON PACKAGE STRUCTURE
-# ===========================================
-ARF_OSS_AVAILABLE = False
-OSS_VERSION = "3.3.6"
-HealingIntent = None
-IntentSource = None
-IntentStatus = None
-OSSMCPClient = None
-
+# Import Plotly early to ensure availability
 try:
-    # ATTEMPT 1: Import from public package (correct based on pyproject.toml)
-    try:
-        from agentic_reliability_framework import __version__ as arf_version
-        from agentic_reliability_framework.models import HealingIntent, IntentSource, IntentStatus
-        from agentic_reliability_framework.engine import OSSMCPClient
-        
-        ARF_OSS_AVAILABLE = True
-        OSS_VERSION = arf_version
-        logger.info(f"✅ Successfully imported ARF OSS v{OSS_VERSION} from public package")
-        
-    except ImportError as e1:
-        logger.debug(f"Attempt 1 failed: {e1}")
-        
-        # ATTEMPT 2: Import from modules (development structure)
-        try:
-            # For Hugging Face demo, use enhanced mock classes
-            logger.info("Using enhanced mock classes for demo environment")
-            
-            # Define enums matching the actual structure
-            class IntentSource:
-                OSS_ANALYSIS = "oss_analysis"
-                RAG_SIMILARITY = "rag_similarity"
-                HUMAN_OVERRIDE = "human_override"
-                AUTOMATED_LEARNING = "automated_learning"
-                
-            class IntentStatus:
-                CREATED = "created"
-                OSS_ADVISORY_ONLY = "oss_advisory_only"
-                PENDING_EXECUTION = "pending_execution"
-                EXECUTING = "executing"
-                COMPLETED = "completed"
-                FAILED = "failed"
-                
-            # Enhanced HealingIntent based on actual structure
-            class HealingIntent:
-                def __init__(self, action: str, component: str, parameters: Dict, **kwargs):
-                    self.action = action
-                    self.component = component
-                    self.parameters = parameters
-                    self.justification = kwargs.get('justification', '')
-                    self.confidence = kwargs.get('confidence', 0.85)
-                    self.similar_incidents = kwargs.get('similar_incidents', [])
-                    self.rag_similarity_score = kwargs.get('rag_similarity_score')
-                    self.source = kwargs.get('source', IntentSource.OSS_ANALYSIS)
-                    self.status = kwargs.get('status', IntentStatus.CREATED)
-                    self.intent_id = kwargs.get('intent_id', f"intent_{int(time.time())}")
-                    self.oss_edition = "oss"
-                    self.requires_enterprise = True
-                    self.execution_allowed = False
-                    self.created_at = time.time()
-                    
-                def to_enterprise_request(self) -> Dict:
-                    return {
-                        'action': self.action,
-                        'component': self.component,
-                        'parameters': self.parameters,
-                        'justification': self.justification,
-                        'confidence': self.confidence,
-                        'requires_enterprise': self.requires_enterprise,
-                        'oss_metadata': {
-                            'similar_incidents_count': len(self.similar_incidents),
-                            'rag_used': self.rag_similarity_score is not None,
-                            'source': self.source,
-                            'oss_edition': self.oss_edition,
-                            'execution_allowed': self.execution_allowed
-                        },
-                        'intent_id': self.intent_id,
-                        'created_at': self.created_at
-                    }
-                
-                def mark_as_oss_advisory(self):
-                    self.status = IntentStatus.OSS_ADVISORY_ONLY
-                    self.execution_allowed = False
-                    return self
-                
-                @classmethod
-                def from_analysis(cls, action: str, component: str, parameters: Dict, 
-                                justification: str, confidence: float, **kwargs):
-                    return cls(
-                        action=action,
-                        component=component,
-                        parameters=parameters,
-                        justification=justification,
-                        confidence=confidence,
-                        similar_incidents=kwargs.get('similar_incidents'),
-                        rag_similarity_score=kwargs.get('rag_similarity_score'),
-                        source=kwargs.get('source', IntentSource.OSS_ANALYSIS)
-                    )
-            
-            class OSSMCPClient:
-                def __init__(self):
-                    self.mode = "advisory"
-                    
-                async def analyze_and_recommend(self, tool_name: str, component: str, 
-                                              parameters: Dict, context: Optional[Dict] = None) -> HealingIntent:
-                    similar_incidents = [
-                        {"id": "inc_001", "similarity": 0.78, "resolution": "scaled_out", 
-                         "component": "redis", "success": True, "timestamp": "2024-01-15T10:30:00"},
-                        {"id": "inc_045", "similarity": 0.65, "resolution": "restarted", 
-                         "component": "database", "success": True, "timestamp": "2024-01-10T14:20:00"},
-                        {"id": "inc_089", "similarity": 0.59, "resolution": "circuit_breaker", 
-                         "component": "api", "success": False, "timestamp": "2024-01-05T09:15:00"}
-                    ]
-                    
-                    rag_score = sum(inc["similarity"] for inc in similar_incidents[:3]) / 3 if similar_incidents else 0.67
-                    
-                    return HealingIntent.from_analysis(
-                        action=tool_name,
-                        component=component,
-                        parameters=parameters,
-                        justification=f"OSS Analysis: Based on {len(similar_incidents)} similar historical incidents with {rag_score:.0%} average similarity",
-                        confidence=0.82 + (len(similar_incidents) * 0.01),
-                        similar_incidents=similar_incidents,
-                        rag_similarity_score=rag_score,
-                        source=IntentSource.RAG_SIMILARITY
-                    ).mark_as_oss_advisory()
-            
-            # Set module-level variables
-            IntentSource = IntentSource
-            IntentStatus = IntentStatus
-            OSSMCPClient = OSSMCPClient
-            logger.info("✅ Using enhanced mock classes for demo")
-            
-        except Exception as e2:
-            logger.warning(f"Enhanced mock creation failed: {e2}")
-            
-            # Minimal fallback
-            class HealingIntent:
-                def __init__(self, **kwargs):
-                    pass
-                def to_enterprise_request(self):
-                    return {"error": "ARF not available"}
-                @classmethod
-                def from_analysis(cls, **kwargs):
-                    return cls()
-                def mark_as_oss_advisory(self):
-                    return self
-            
-            class OSSMCPClient:
-                def __init__(self):
-                    self.mode = "advisory"
-                async def analyze_and_recommend(self, **kwargs):
-                    return HealingIntent()
-
-except Exception as e:
-    logger.error(f"❌ CRITICAL: Failed to initialize ARF framework: {e}")
-    logger.error(traceback.format_exc())
-    # Provide absolute minimal fallbacks
-    class HealingIntent:
-        def __init__(self, **kwargs):
-            pass
-        def to_enterprise_request(self):
-            return {"error": "ARF not available"}
-        @classmethod
-        def from_analysis(cls, **kwargs):
-            return cls()
-    class OSSMCPClient:
-        async def analyze_and_recommend(self, **kwargs):
-            return HealingIntent()
+    import plotly.graph_objects as go
+    import plotly.express as px
+    from plotly.subplots import make_subplots
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    logger.warning("Plotly not available - visualizations will be simplified")
+    PLOTLY_AVAILABLE = False
 
 # ===========================================
-# IMPORT SUPPORTING MODULES
+# IMPORT MODULAR COMPONENTS
 # ===========================================
 try:
+    # Import scenarios from your modular file
+    from demo.scenarios import INCIDENT_SCENARIOS as SCENARIOS_DATA
+    
+    # Import orchestrator
+    from demo.orchestrator import DemoOrchestrator
+    
     # Import UI components
     from ui.components import (
         create_header, create_status_bar, create_tab1_incident_demo,
@@ -212,28 +56,26 @@ try:
         create_footer
     )
     
-    # Import demo orchestrator
-    from demo.orchestrator import DemoOrchestrator
-    
-    # Import visualizations
-    from core.visualizations import EnhancedVisualizationEngine
-    
-    logger.info("✅ Successfully imported all supporting modules")
+    logger.info("✅ Successfully imported all modular components")
     
 except ImportError as e:
-    logger.warning(f"Could not import some modules: {e}")
-    # We'll define minimal versions inline if needed
+    logger.error(f"Failed to import components: {e}")
+    logger.error(traceback.format_exc())
+    # Fallback to inline definitions
+    SCENARIOS_DATA = {}
+    DemoOrchestrator = None
 
 # ===========================================
-# INCIDENT SCENARIOS (from original app.py)
+# ENHANCED SCENARIOS WITH OSS vs ENTERPRISE SEPARATION
 # ===========================================
-INCIDENT_SCENARIOS = {
+ENHANCED_SCENARIOS = {
     "Cache Miss Storm": {
         "description": "Redis cluster experiencing 80% cache miss rate causing database overload",
         "severity": "CRITICAL",
+        "component": "redis_cache",
         "metrics": {
             "Cache Hit Rate": "18.5% (Critical)",
-            "Database Load": "92% (Overloaded)", 
+            "Database Load": "92% (Overloaded)",
             "Response Time": "1850ms (Slow)",
             "Affected Users": "45,000",
             "Eviction Rate": "125/sec"
@@ -245,31 +87,43 @@ INCIDENT_SCENARIOS = {
             "SLA Violation": "Yes",
             "Customer Sat": "-40%"
         },
-        "component": "redis_cache",
-        "oss_analysis": {
-            "status": "✅ ARF OSS Analysis Complete",
+        # OSS RESULTS - ADVISORY ONLY
+        "oss_results": {
+            "status": "✅ OSS Analysis Complete",
+            "confidence": 0.87,
+            "similar_incidents": 3,
+            "rag_similarity_score": 0.72,
             "recommendations": [
-                "Increase Redis cache memory allocation",
+                "Scale Redis cache memory from 4GB → 8GB",
                 "Implement cache warming strategy",
-                "Optimize key patterns",
+                "Optimize key patterns with TTL adjustments",
                 "Add circuit breaker for database fallback"
             ],
-            "estimated_time": "60+ minutes",
+            "estimated_time": "60+ minutes manually",
             "engineers_needed": "2-3 SREs + 1 DBA",
-            "manual_effort": "High",
-            "total_cost": "$8,500"
+            "advisory_only": True,
+            "healing_intent": {
+                "action": "scale_out",
+                "component": "redis_cache",
+                "parameters": {"scale_factor": 2.0},
+                "confidence": 0.87,
+                "requires_enterprise": True
+            }
         },
+        # ENTERPRISE RESULTS - ACTUAL EXECUTION
         "enterprise_results": {
-            "actions_completed": [
+            "execution_mode": "Autonomous",
+            "actions_executed": [
                 "✅ Auto-scaled Redis cluster: 4GB → 8GB",
-                "✅ Deployed intelligent cache warming",
-                "✅ Optimized 12 key patterns with ML",
-                "✅ Implemented circuit breaker"
+                "✅ Deployed intelligent cache warming service",
+                "✅ Optimized 12 key patterns with ML recommendations",
+                "✅ Implemented circuit breaker with 95% success rate"
             ],
             "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",
@@ -277,12 +131,20 @@ INCIDENT_SCENARIOS = {
                 "Users Impacted": "45,000 → 0",
                 "Revenue Protected": "$1,700",
                 "MTTR Improvement": "80% reduction"
+            },
+            "audit_info": {
+                "execution_id": "exec_001",
+                "timestamp": datetime.datetime.now().isoformat(),
+                "approval_required": False,
+                "success": True
             }
         }
     },
+    
     "Database Connection Pool Exhaustion": {
-        "description": "Database connection pool exhausted causing API timeouts and user failures",
+        "description": "PostgreSQL connection pool exhausted causing API timeouts",
         "severity": "HIGH",
+        "component": "postgresql_database",
         "metrics": {
             "Active Connections": "98/100 (Critical)",
             "API Latency": "2450ms",
@@ -296,415 +158,559 @@ INCIDENT_SCENARIOS = {
             "SLA Violation": "Yes",
             "Partner Impact": "3 external APIs"
         },
-        "component": "database"
+        "oss_results": {
+            "status": "✅ OSS Analysis Complete",
+            "confidence": 0.82,
+            "similar_incidents": 2,
+            "rag_similarity_score": 0.65,
+            "recommendations": [
+                "Increase connection pool size from 100 → 200",
+                "Implement connection pooling monitoring",
+                "Add query timeout enforcement",
+                "Deploy read replica for read-heavy queries"
+            ],
+            "estimated_time": "45+ minutes manually",
+            "engineers_needed": "1 DBA + 1 Backend Engineer",
+            "advisory_only": True,
+            "healing_intent": {
+                "action": "scale_connection_pool",
+                "component": "postgresql_database",
+                "parameters": {"max_connections": 200},
+                "confidence": 0.82,
+                "requires_enterprise": True
+            }
+        },
+        "enterprise_results": {
+            "execution_mode": "Approval Required",
+            "actions_executed": [
+                "✅ Increased connection pool: 100 → 200 connections",
+                "✅ Deployed real-time connection monitoring",
+                "✅ Implemented query timeout: 30s → 10s",
+                "✅ Automated read replica traffic routing"
+            ],
+            "metrics_improvement": {
+                "API Latency": "2450ms → 320ms",
+                "Error Rate": "15.2% → 0.8%",
+                "Connection Wait": "45s → 120ms",
+                "Throughput": "850 → 2100 req/sec"
+            },
+            "business_impact": {
+                "Recovery Time": "45 min → 8 min",
+                "Cost Saved": "$3,150",
+                "Failed Transactions": "12,500 → 0",
+                "SLA Compliance": "Restored to 99.9%"
+            },
+            "audit_info": {
+                "execution_id": "exec_002",
+                "timestamp": datetime.datetime.now().isoformat(),
+                "approval_required": True,
+                "success": True
+            }
+        }
     },
-    "Memory Leak in Production": {
-        "description": "Java service memory leak causing gradual performance degradation",
+    
+    "Kubernetes Memory Leak": {
+        "description": "Java microservice memory leak causing pod restarts",
         "severity": "HIGH",
+        "component": "java_payment_service",
         "metrics": {
             "Memory Usage": "96% (Critical)",
             "GC Pause Time": "4500ms",
             "Error Rate": "28.5%",
-            "Restart Frequency": "12/hour",
+            "Pod Restarts": "12/hour",
             "Heap Fragmentation": "42%"
         },
         "impact": {
             "Revenue Loss": "$5,500/hour",
             "Session Loss": "8,500 users",
-            "Customer Impact": "High",
+            "Payment Failures": "3.2% of transactions",
             "Support Tickets": "+300%"
         },
-        "component": "java_service"
+        "oss_results": {
+            "status": "✅ OSS Analysis Complete",
+            "confidence": 0.79,
+            "similar_incidents": 4,
+            "rag_similarity_score": 0.68,
+            "recommendations": [
+                "Increase pod memory limits from 2GB → 4GB",
+                "Implement memory leak detection",
+                "Deploy canary with fixed version",
+                "Add circuit breaker for graceful degradation"
+            ],
+            "estimated_time": "90+ minutes manually",
+            "engineers_needed": "2 Java Devs + 1 SRE",
+            "advisory_only": True,
+            "healing_intent": {
+                "action": "scale_memory",
+                "component": "java_payment_service",
+                "parameters": {"memory_limit_gb": 4},
+                "confidence": 0.79,
+                "requires_enterprise": True
+            }
+        },
+        "enterprise_results": {
+            "execution_mode": "Autonomous with Rollback",
+            "actions_executed": [
+                "✅ Scaled pod memory: 2GB → 4GB with monitoring",
+                "✅ Deployed memory leak detection service",
+                "✅ Rolled out canary with memory fixes",
+                "✅ Implemented auto-rollback on failure"
+            ],
+            "metrics_improvement": {
+                "Memory Usage": "96% → 68%",
+                "GC Pause Time": "4500ms → 320ms",
+                "Error Rate": "28.5% → 1.2%",
+                "Pod Stability": "12/hour → 0 restarts"
+            },
+            "business_impact": {
+                "Recovery Time": "90 min → 15 min",
+                "Cost Saved": "$4,950",
+                "Transaction Success": "96.8% → 99.9%",
+                "User Impact": "8,500 → 0 affected"
+            },
+            "audit_info": {
+                "execution_id": "exec_003",
+                "timestamp": datetime.datetime.now().isoformat(),
+                "approval_required": False,
+                "success": True
+            }
+        }
+    },
+    
+    "API Rate Limit Storm": {
+        "description": "Third-party API rate limiting causing cascading failures",
+        "severity": "MEDIUM",
+        "component": "external_api_gateway",
+        "metrics": {
+            "Rate Limit Hits": "95% of requests",
+            "Error Rate": "42.8%",
+            "Retry Storm": "Active",
+            "Cascade Effect": "3 dependent services",
+            "Queue Backlog": "8,500 requests"
+        },
+        "impact": {
+            "Revenue Loss": "$3,800/hour",
+            "Partner SLA Breach": "Yes",
+            "Data Sync Delay": "4+ hours",
+            "Customer Reports": "Delayed by 6 hours"
+        },
+        "oss_results": {
+            "status": "✅ OSS Analysis Complete",
+            "confidence": 0.85,
+            "similar_incidents": 3,
+            "rag_similarity_score": 0.71,
+            "recommendations": [
+                "Implement exponential backoff with jitter",
+                "Deploy circuit breaker pattern",
+                "Add request queuing with prioritization",
+                "Implement adaptive rate limiting"
+            ],
+            "estimated_time": "75+ minutes manually",
+            "engineers_needed": "2 Backend Engineers + 1 DevOps",
+            "advisory_only": True,
+            "healing_intent": {
+                "action": "implement_rate_limiting",
+                "component": "external_api_gateway",
+                "parameters": {"backoff_strategy": "exponential"},
+                "confidence": 0.85,
+                "requires_enterprise": True
+            }
+        },
+        "enterprise_results": {
+            "execution_mode": "Autonomous",
+            "actions_executed": [
+                "✅ Implemented exponential backoff: 1s → 32s with jitter",
+                "✅ Deployed circuit breaker with 80% success threshold",
+                "✅ Added intelligent request queuing",
+                "✅ Enabled adaptive rate limiting based on API health"
+            ],
+            "metrics_improvement": {
+                "Rate Limit Hits": "95% → 12%",
+                "Error Rate": "42.8% → 3.5%",
+                "Successful Retries": "18% → 89%",
+                "Queue Processing": "8,500 → 0 backlog"
+            },
+            "business_impact": {
+                "Recovery Time": "75 min → 10 min",
+                "Cost Saved": "$3,420",
+                "SLA Compliance": "Restored within 5 minutes",
+                "Data Freshness": "4+ hours → <5 minute delay"
+            },
+            "audit_info": {
+                "execution_id": "exec_004",
+                "timestamp": datetime.datetime.now().isoformat(),
+                "approval_required": False,
+                "success": True
+            }
+        }
     }
 }
 
 # ===========================================
-# AUDIT TRAIL MANAGER (from original app.py)
+# SIMPLE VISUALIZATION ENGINE (No external dependencies)
 # ===========================================
-class AuditTrailManager:
-    """Manage audit trail and execution history"""
-    
-    def __init__(self):
-        self.execution_history = []
-        self.incident_history = []
-        self._initialize_sample_data()
+class SimpleVizEngine:
+    """Simple visualization engine that works without complex imports"""
     
-    def _initialize_sample_data(self):
-        """Initialize with sample historical data"""
-        base_time = datetime.datetime.now() - datetime.timedelta(hours=2)
+    @staticmethod
+    def create_timeline_plot(scenario_name="Incident"):
+        """Create a simple timeline plot"""
+        if not PLOTLY_AVAILABLE:
+            # Return a placeholder if plotly not available
+            import matplotlib.pyplot as plt
+            import io
+            import base64
+            
+            fig, ax = plt.subplots(figsize=(10, 4))
+            events = ['Detection', 'Analysis', 'Action', 'Recovery']
+            times = [0, 1, 2, 3]
+            
+            ax.plot(times, [1, 1, 1, 1], 'bo-', markersize=10)
+            for i, (event, t) in enumerate(zip(events, times)):
+                ax.text(t, 1.1, event, ha='center', fontsize=10)
+            
+            ax.set_ylim(0.5, 1.5)
+            ax.set_xlim(-0.5, 3.5)
+            ax.set_title(f'Timeline: {scenario_name}')
+            ax.axis('off')
+            
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png', bbox_inches='tight')
+            plt.close(fig)
+            buf.seek(0)
+            
+            return f"data:image/png;base64,{base64.b64encode(buf.read()).decode()}"
         
-        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"
-            ),
-        ]
+        # Use Plotly if available
+        fig = go.Figure()
         
-        self.execution_history = sample_executions
+        events = [
+            {"time": "T-5m", "event": "Detection", "type": "detection"},
+            {"time": "T-3m", "event": "OSS Analysis", "type": "analysis"},
+            {"time": "T-2m", "event": "Enterprise Action", "type": "action"},
+            {"time": "T-0m", "event": "Recovery", "type": "recovery"}
+        ]
         
-        services = ["API Gateway", "Database", "Redis Cache", "Auth Service"]
+        for event in events:
+            fig.add_trace(go.Scatter(
+                x=[event["time"]],
+                y=[1],
+                mode='markers+text',
+                marker=dict(size=20, color='#4ECDC4'),
+                text=[event["event"]],
+                textposition="top center"
+            ))
+        
+        fig.update_layout(
+            title=f"Timeline: {scenario_name}",
+            height=300,
+            showlegend=False,
+            yaxis=dict(showticklabels=False, range=[0.5, 1.5]),
+            margin=dict(l=20, r=20, t=40, b=20)
+        )
         
-        for i in range(8):
-            incident_time = base_time - datetime.timedelta(minutes=i * 15)
-            self.incident_history.append({
-                "timestamp": incident_time,
-                "time_str": incident_time.strftime("%H:%M"),
-                "service": services[i % len(services)],
-                "type": "Cache Miss Storm" if i % 3 == 0 else "Memory Leak",
-                "severity": 3 if i % 3 == 0 else 2,
-                "description": f"High latency on {services[i % len(services)]}",
-                "id": f"inc_{i:03d}"
-            })
+        return fig
     
-    def _create_execution_entry(self, timestamp, scenario, actions, savings, status, details):
-        return {
-            "timestamp": timestamp,
-            "time_str": timestamp.strftime("%H:%M"),
-            "scenario": scenario,
-            "actions": str(actions),
+    @staticmethod
+    def create_dashboard_plot():
+        """Create simple dashboard plot"""
+        if not PLOTLY_AVAILABLE:
+            return None
+        
+        fig = make_subplots(rows=1, cols=2, subplot_titles=('Cost Savings', 'MTTR Improvement'))
+        
+        # Cost savings
+        fig.add_trace(
+            go.Bar(x=['Without ARF', 'With ARF'], y=[100, 25], name='Cost'),
+            row=1, col=1
+        )
+        
+        # MTTR improvement
+        fig.add_trace(
+            go.Bar(x=['Manual', 'ARF OSS', 'ARF Enterprise'], y=[120, 25, 8], name='MTTR'),
+            row=1, col=2
+        )
+        
+        fig.update_layout(height=400, showlegend=False)
+        return fig
+
+# ===========================================
+# AUDIT TRAIL MANAGER
+# ===========================================
+class AuditTrailManager:
+    def __init__(self):
+        self.executions = []
+        self.incidents = []
+        
+    def add_execution(self, scenario_name, mode, success=True, savings=0):
+        entry = {
+            "id": f"exec_{len(self.executions):03d}",
+            "time": datetime.datetime.now().strftime("%H:%M"),
+            "scenario": scenario_name,
+            "mode": mode,
+            "status": "✅ Success" if success else "❌ Failed",
             "savings": f"${savings:,}",
-            "status": status,
-            "details": details,
-            "id": f"exec_{len(self.execution_history):03d}"
+            "details": f"{mode} execution"
         }
-    
-    def add_execution(self, scenario: str, actions: List[str], 
-                     savings: int, approval_required: bool, details: str = ""):
-        entry = self._create_execution_entry(
-            datetime.datetime.now(),
-            scenario,
-            len(actions),
-            savings,
-            "✅ Approved & Executed" if approval_required else "✅ Auto-Executed",
-            details
-        )
-        self.execution_history.insert(0, entry)
+        self.executions.insert(0, entry)
         return entry
     
-    def add_incident(self, scenario_name: str, metrics: Dict):
+    def add_incident(self, scenario_name, severity="HIGH"):
         entry = {
-            "timestamp": datetime.datetime.now(),
-            "time_str": datetime.datetime.now().strftime("%H:%M"),
-            "service": "Demo System",
-            "type": scenario_name,
-            "severity": 3,
-            "description": f"Demo incident: {scenario_name}",
-            "id": f"inc_{len(self.incident_history):03d}"
+            "id": f"inc_{len(self.incidents):03d}",
+            "time": datetime.datetime.now().strftime("%H:%M"),
+            "scenario": scenario_name,
+            "severity": severity,
+            "component": ENHANCED_SCENARIOS.get(scenario_name, {}).get("component", "unknown"),
+            "status": "Analyzed"
         }
-        self.incident_history.insert(0, entry)
+        self.incidents.insert(0, entry)
         return entry
     
-    def get_execution_history_table(self, limit: int = 10) -> List[List]:
+    def get_execution_table(self):
         return [
-            [entry["time_str"], entry["scenario"], entry["actions"], 
-             entry["status"], entry["savings"], entry["details"]]
-            for entry in self.execution_history[:limit]
+            [e["time"], e["scenario"], e["mode"], e["status"], e["savings"], e["details"]]
+            for e in self.executions[:10]
         ]
     
-    def get_incident_history_table(self, limit: int = 15) -> List[List]:
+    def get_incident_table(self):
         return [
-            [entry["time_str"], entry["service"], entry["type"], 
-             f"{entry['severity']}/3", entry["description"]]
-            for entry in self.incident_history[:limit]
+            [e["time"], e["component"], e["scenario"], e["severity"], e["status"]]
+            for e in self.incidents[:15]
         ]
-    
-    def export_audit_trail(self) -> str:
-        total_savings = sum(
-            int(e["savings"].replace("$", "").replace(",", ""))
-            for e in self.execution_history
-            if "$" in e["savings"]
-        )
-        
-        return json.dumps({
-            "executions": self.execution_history,
-            "incidents": 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,
-            "arf_version": OSS_VERSION,
-            "oss_available": ARF_OSS_AVAILABLE
-        }, indent=2, default=str)
 
 # ===========================================
-# CREATE DEMO INTERFACE - CORRECTED
+# CREATE DEMO INTERFACE - FIXED VERSION
 # ===========================================
 def create_demo_interface():
-    """Create the 5-tab demo interface - CORRECTED VERSION"""
+    """Create the demo interface with all fixes applied"""
     
-    # Import gradio here to avoid issues
     import gradio as gr
     
     # Initialize components
+    viz_engine = SimpleVizEngine()
     audit_manager = AuditTrailManager()
     
-    # Create OSS client
-    oss_client = OSSMCPClient() if OSSMCPClient else None
-    
-    # Create orchestrator
-    orchestrator = DemoOrchestrator(arf_client=oss_client)
-    
-    # Create visualization engine
-    try:
-        viz_engine = EnhancedVisualizationEngine()
-    except:
-        # Fallback to simple visualizations
-        class SimpleVizEngine:
-            def create_interactive_timeline(self, scenario):
-                import plotly.graph_objects as go
-                fig = go.Figure()
-                fig.add_trace(go.Scatter(x=[1,2,3], y=[1,2,1]))
-                fig.update_layout(title="Timeline", height=400)
-                return fig
-            def create_executive_dashboard(self, roi=None):
-                import plotly.graph_objects as go
-                fig = go.Figure()
-                fig.add_trace(go.Bar(x=['A','B','C'], y=[1,2,3]))
-                fig.update_layout(title="Dashboard", height=400)
-                return fig
-        viz_engine = SimpleVizEngine()
+    # Initialize orchestrator if available
+    orchestrator = None
+    if DemoOrchestrator:
+        try:
+            orchestrator = DemoOrchestrator()
+        except:
+            pass
     
-    # Custom CSS
+    # Custom CSS for OSS vs Enterprise separation
     custom_css = """
-    .gradio-container {
-        max-width: 1800px !important;
-        margin: auto !important;
-        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif !important;
-    }
-    h1 {
-        background: linear-gradient(90deg, #1a365d 0%, #2d3748 100%);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        background-clip: text;
-        font-weight: 800 !important;
-        font-size: 2.5rem !important;
-        margin-bottom: 0.5rem !important;
+    .oss-section {
+        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%) !important;
+        border-left: 4px solid #2196f3 !important;
+        padding: 15px !important;
+        border-radius: 8px !important;
+        margin-bottom: 15px !important;
     }
-    .critical { color: #FF6B6B !important; font-weight: 900 !important; }
-    .success { color: #4ECDC4 !important; font-weight: 900 !important; }
-    .tab-nav { background: linear-gradient(90deg, #f8fafc 0%, #ffffff 100%) !important; }
-    .metric-card {
-        background: white !important;
-        border-radius: 10px !important;
-        padding: 20px !important;
-        box-shadow: 0 2px 8px rgba(0,0,0,0.06) !important;
-        border-left: 4px solid #4ECDC4 !important;
+    .enterprise-section {
+        background: linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%) !important;
+        border-left: 4px solid #4caf50 !important;
+        padding: 15px !important;
+        border-radius: 8px !important;
         margin-bottom: 15px !important;
     }
+    .critical { color: #d32f2f !important; font-weight: bold; }
+    .success { color: #388e3c !important; font-weight: bold; }
     """
     
-    with gr.Blocks(
-        title=f"🚀 ARF Investor Demo v3.8.0",
-        theme=gr.themes.Soft(
-            primary_hue="blue",
-            secondary_hue="teal"
-        ),
-        css=custom_css
-    ) as demo:
+    with gr.Blocks(title="🚀 ARF Investor Demo v3.8.0", css=custom_css) as demo:
         
-        # ============ HEADER ============
-        create_header(OSS_VERSION, ARF_OSS_AVAILABLE)
+        # Use your modular header
+        create_header("3.3.6", False)  # OSS version, Mock mode
         
-        # ============ STATUS BAR ============
+        # Status bar
         create_status_bar()
         
-        # ============ 5 TABS ============
+        # Tabs
         with gr.Tabs():
             
-            # TAB 1: LIVE INCIDENT DEMO
+            # TAB 1: Live Incident Demo (Fixed)
             with gr.TabItem("🔥 Live Incident Demo"):
-                # Get components from UI module
+                # Get components from your UI module
                 (scenario_dropdown, scenario_description, metrics_display, impact_display,
                  timeline_output, oss_btn, enterprise_btn, approval_toggle, demo_btn,
                  approval_display, config_display, results_display) = create_tab1_incident_demo(
-                    INCIDENT_SCENARIOS, "Cache Miss Storm"
+                    ENHANCED_SCENARIOS, "Cache Miss Storm"
                 )
+                
+                # Add OSS and Enterprise results displays
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 📋 OSS Analysis Results (Advisory Only)")
+                        oss_results = gr.JSON(
+                            value={},
+                            label=""
+                        )
+                    
+                    with gr.Column():
+                        gr.Markdown("### 🎯 Enterprise Execution Results")
+                        enterprise_results = gr.JSON(
+                            value={},
+                            label=""
+                        )
             
-            # TAB 2: BUSINESS IMPACT & ROI
+            # TAB 2: Business Impact & ROI
             with gr.TabItem("💰 Business Impact & ROI"):
                 (dashboard_output, monthly_slider, impact_slider, team_slider,
                  calculate_btn, roi_output) = create_tab2_business_roi()
             
-            # TAB 3: AUDIT TRAIL & HISTORY
+            # TAB 3: Audit Trail
             with gr.TabItem("📜 Audit Trail & History"):
                 (refresh_btn, clear_btn, export_btn, execution_table, savings_chart,
                  incident_table, memory_graph, export_text) = create_tab3_audit_trail()
             
-            # TAB 4: ENTERPRISE FEATURES
+            # Other tabs...
             with gr.TabItem("🏢 Enterprise Features"):
-                (license_display, validate_btn, trial_btn, upgrade_btn, features_table,
-                 compliance_display, integrations_table, mcp_mode) = create_tab4_enterprise_features()
+                create_tab4_enterprise_features()
             
-            # TAB 5: LEARNING ENGINE
             with gr.TabItem("🧠 Learning Engine"):
-                (learning_graph, graph_type, show_labels, search_query, search_btn,
-                 clear_btn_search, search_results, stats_display, patterns_display,
-                 performance_display) = create_tab5_learning_engine()
+                create_tab5_learning_engine()
         
-        # ============ FOOTER ============
+        # Footer
         create_footer()
         
-        # ============ EVENT HANDLERS ============
+        # ============ EVENT HANDLERS (FIXED) ============
         
-        # Scenario dropdown change
+        # Update scenario (FIXED: Proper parameter handling)
         def update_scenario(scenario_name):
-            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-            timeline = viz_engine.create_interactive_timeline(scenario)
+            scenario = ENHANCED_SCENARIOS.get(scenario_name, {})
+            
+            # Get timeline plot
+            if PLOTLY_AVAILABLE:
+                timeline = viz_engine.create_timeline_plot(scenario_name)
+            else:
+                timeline = None
+            
             return (
                 f"### {scenario_name}\n{scenario.get('description', 'No description')}",
                 scenario.get("metrics", {}),
                 scenario.get("impact", {}),
-                timeline
+                timeline if timeline else gr.Plot(visible=False),
+                {},  # Clear OSS results
+                {}   # Clear Enterprise results
             )
         
         scenario_dropdown.change(
             fn=update_scenario,
             inputs=[scenario_dropdown],
-            outputs=[scenario_description, metrics_display, impact_display, timeline_output]
+            outputs=[scenario_description, metrics_display, impact_display,
+                    timeline_output, oss_results, enterprise_results]
         )
         
-        # OSS Analysis button
+        # Run OSS Analysis (FIXED: Proper async handling)
         async def run_oss_analysis(scenario_name):
-            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
-            analysis = await orchestrator.analyze_incident(scenario_name, scenario)
+            scenario = ENHANCED_SCENARIOS.get(scenario_name, {})
             
             # Add to audit trail
-            audit_manager.add_incident(scenario_name, scenario.get("metrics", {}))
+            audit_manager.add_incident(scenario_name, scenario.get("severity", "HIGH"))
+            
+            # Get OSS results
+            oss_result = scenario.get("oss_results", {})
             
             # Update tables
-            incident_table_data = audit_manager.get_incident_history_table()
+            incident_table_data = audit_manager.get_incident_table()
             
-            return analysis, incident_table_data
+            return oss_result, incident_table_data
         
         oss_btn.click(
             fn=run_oss_analysis,
             inputs=[scenario_dropdown],
-            outputs=[results_display, incident_table]
+            outputs=[oss_results, incident_table]
         )
         
-        # Enterprise Healing button
-        def execute_healing(scenario_name, approval_required):
-            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
+        # Execute Enterprise Healing (FIXED: Proper parameter matching)
+        def execute_enterprise_healing(scenario_name, approval_required):
+            scenario = ENHANCED_SCENARIOS.get(scenario_name, {})
             
-            # Create mock healing intent
-            healing_intent = {
-                "action": "scale_out",
-                "component": scenario.get("component", "unknown"),
-                "parameters": {"scale_factor": 2},
-                "justification": f"Healing {scenario_name}"
-            }
+            # Get enterprise results
+            enterprise_result = scenario.get("enterprise_results", {})
             
-            # Execute through orchestrator
-            execution = orchestrator.execute_healing(
-                scenario_name, 
-                healing_intent,
-                mode="approval" if approval_required else "autonomous"
-            )
+            # Determine mode
+            mode = "Approval" if approval_required else "Autonomous"
+            
+            # Calculate savings from impact
+            impact = scenario.get("impact", {})
+            revenue_loss = impact.get("Revenue Loss", "$0")
+            try:
+                savings = int(revenue_loss.replace("$", "").replace(",", "").split("/")[0]) * 0.85
+            except:
+                savings = 5000
             
             # Add to audit trail
             audit_manager.add_execution(
                 scenario_name,
-                ["scale_out", "circuit_breaker", "monitoring"],
-                7200,
-                approval_required,
-                f"Healed {scenario_name}"
+                mode,
+                savings=int(savings)
             )
             
-            # Create approval HTML
+            # Create approval display
             if approval_required:
-                approval_html = """
-                <div style='padding: 20px; background: #e8f5e8; border-radius: 10px; border-left: 4px solid #28a745;'>
-                    <div style='display: flex; align-items: center; gap: 10px; margin-bottom: 15px;'>
-                        <div style='background: #28a745; color: white; width: 32px; height: 32px; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-weight: bold;'>
-                            ✅
-                        </div>
-                        <h4 style='margin: 0; color: #1a365d;'>Approved & Executed</h4>
-                    </div>
-                    <div style='color: #2d3748;'>
-                        Action approved by system administrator and executed successfully.
-                    </div>
+                approval_html = f"""
+                <div class='enterprise-section'>
+                    <h4>✅ Approved & Executed</h4>
+                    <p>Action for <strong>{scenario_name}</strong> was approved by system administrator and executed successfully.</p>
+                    <p><strong>Mode:</strong> Manual Approval</p>
+                    <p><strong>Cost Saved:</strong> ${int(savings):,}</p>
                 </div>
                 """
             else:
-                approval_html = """
-                <div style='padding: 20px; background: #e3f2fd; border-radius: 10px; border-left: 4px solid #2196f3;'>
-                    <div style='display: flex; align-items: center; gap: 10px; margin-bottom: 15px;'>
-                        <div style='background: #2196f3; color: white; width: 32px; height: 32px; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-weight: bold;'>
-                            ⚡
-                        </div>
-                        <h4 style='margin: 0; color: #1a365d;'>Auto-Executed</h4>
-                    </div>
-                    <div style='color: #2d3748;'>
-                        Action executed autonomously by ARF Enterprise.
-                    </div>
+                approval_html = f"""
+                <div class='enterprise-section'>
+                    <h4>⚡ Auto-Executed</h4>
+                    <p>Action for <strong>{scenario_name}</strong> was executed autonomously by ARF Enterprise.</p>
+                    <p><strong>Mode:</strong> Fully Autonomous</p>
+                    <p><strong>Cost Saved:</strong> ${int(savings):,}</p>
                 </div>
                 """
             
             # Update execution table
-            execution_table_data = audit_manager.get_execution_history_table()
+            execution_table_data = audit_manager.get_execution_table()
             
-            return approval_html, execution, execution_table_data
+            return approval_html, enterprise_result, execution_table_data
         
         enterprise_btn.click(
-            fn=execute_healing,
+            fn=execute_enterprise_healing,
             inputs=[scenario_dropdown, approval_toggle],
-            outputs=[approval_display, results_display, execution_table]
+            outputs=[approval_display, enterprise_results, execution_table]
         )
         
-        # Quick Demo button
+        # Quick Demo (FIXED: Proper async)
         async def run_quick_demo():
             # Run OSS analysis
-            scenario = INCIDENT_SCENARIOS["Cache Miss Storm"]
-            analysis = await orchestrator.analyze_incident("Cache Miss Storm", scenario)
+            scenario = ENHANCED_SCENARIOS["Cache Miss Storm"]
+            oss_result = scenario.get("oss_results", {})
             
-            # Execute healing
-            execution = orchestrator.execute_healing(
-                "Cache Miss Storm",
-                {"action": "scale_out", "component": "redis_cache"},
-                mode="autonomous"
-            )
+            # Execute enterprise
+            enterprise_result = scenario.get("enterprise_results", {})
             
             # Update audit trail
-            audit_manager.add_incident("Cache Miss Storm", scenario.get("metrics", {}))
-            audit_manager.add_execution(
-                "Cache Miss Storm",
-                ["scale_out", "circuit_breaker"],
-                7200,
-                False,
-                "Quick demo execution"
-            )
+            audit_manager.add_incident("Cache Miss Storm", "CRITICAL")
+            audit_manager.add_execution("Cache Miss Storm", "Autonomous", savings=7200)
             
-            # Update all tables
-            execution_table_data = audit_manager.get_execution_history_table()
-            incident_table_data = audit_manager.get_incident_history_table()
+            # Get table data
+            execution_table_data = audit_manager.get_execution_table()
+            incident_table_data = audit_manager.get_incident_table()
             
-            # Create approval HTML
+            # Create approval display
             approval_html = """
-            <div style='padding: 20px; background: #fff3cd; border-radius: 10px; border-left: 4px solid #ffc107;'>
-                <div style='display: flex; align-items: center; gap: 10px; margin-bottom: 15px;'>
-                    <div style='background: #ffc107; color: white; width: 32px; height: 32px; border-radius: 50%; display: flex; align-items: center; justify-content: center; font-weight: bold;'>
-                        ⚡
-                    </div>
-                    <h4 style='margin: 0; color: #1a365d;'>Quick Demo Completed</h4>
-                </div>
-                <div style='color: #2d3748;'>
-                    OSS analysis → Enterprise execution completed successfully.
-                </div>
+            <div class='enterprise-section'>
+                <h4>⚡ Quick Demo Completed</h4>
+                <p>Full OSS analysis → Enterprise execution completed successfully.</p>
+                <p><strong>Mode:</strong> Autonomous</p>
+                <p><strong>Cost Saved:</strong> $7,200</p>
             </div>
             """
             
             return (
-                analysis,
+                oss_result,
                 approval_html,
-                execution,
+                enterprise_result,
                 execution_table_data,
                 incident_table_data,
                 gr.Checkbox.update(value=False)
@@ -713,38 +719,52 @@ def create_demo_interface():
         demo_btn.click(
             fn=run_quick_demo,
             outputs=[
-                results_display,
+                oss_results,
                 approval_display,
-                results_display,
+                enterprise_results,
                 execution_table,
                 incident_table,
                 approval_toggle
             ]
         )
         
-        # ROI Calculator
+        # ROI Calculator (FIXED)
         def calculate_roi(monthly, impact, team):
-            company_data = {
-                "monthly_incidents": monthly,
-                "avg_cost_per_incident": impact,
-                "team_size": team
-            }
-            roi_result = orchestrator.calculate_roi(company_data)
+            if orchestrator:
+                company_data = {
+                    "monthly_incidents": monthly,
+                    "avg_cost_per_incident": impact,
+                    "team_size": team
+                }
+                roi_result = orchestrator.calculate_roi(company_data)
+            else:
+                # Simple calculation
+                annual = monthly * 12 * impact
+                savings = annual * 0.82
+                team_cost = team * 150000
+                roi_multiplier = savings / team_cost if team_cost > 0 else 0
+                
+                roi_result = {
+                    "annual_impact": annual,
+                    "team_cost": team_cost,
+                    "potential_savings": savings,
+                    "roi_multiplier": roi_multiplier,
+                    "payback_months": (team_cost / (savings / 12)) if savings > 0 else 0
+                }
             
             # Format for display
-            formatted_result = {
-                "annual_impact": f"${roi_result['annual_impact']:,.0f}",
-                "team_cost": f"${roi_result['team_cost']:,.0f}",
-                "potential_savings": f"${roi_result['potential_savings']:,.0f}",
-                "roi_multiplier": f"{roi_result['roi_multiplier']:.1f}×",
-                "payback_months": f"{roi_result['payback_months']:.1f} months",
-                "recommendation": roi_result['recommendation']
+            formatted = {
+                "Annual Impact": f"${roi_result.get('annual_impact', 0):,.0f}",
+                "Team Cost": f"${roi_result.get('team_cost', 0):,.0f}",
+                "Potential Savings": f"${roi_result.get('potential_savings', 0):,.0f}",
+                "ROI Multiplier": f"{roi_result.get('roi_multiplier', 0):.1f}×",
+                "Payback Period": f"{roi_result.get('payback_months', 0):.1f} months"
             }
             
-            # Update dashboard with user-specific ROI
-            dashboard = viz_engine.create_executive_dashboard(roi_result)
+            # Add dashboard
+            dashboard = viz_engine.create_dashboard_plot()
             
-            return formatted_result, dashboard
+            return formatted, dashboard
         
         calculate_btn.click(
             fn=calculate_roi,
@@ -752,101 +772,56 @@ def create_demo_interface():
             outputs=[roi_output, dashboard_output]
         )
         
-        # Audit Trail Refresh
+        # Audit Trail Refresh (FIXED)
         def refresh_audit_trail():
-            execution_table_data = audit_manager.get_execution_history_table()
-            incident_table_data = audit_manager.get_incident_history_table()
-            export_data = audit_manager.export_audit_trail()
-            return execution_table_data, incident_table_data, export_data
+            return audit_manager.get_execution_table(), audit_manager.get_incident_table()
         
         refresh_btn.click(
             fn=refresh_audit_trail,
-            outputs=[execution_table, incident_table, export_text]
+            outputs=[execution_table, incident_table]
         )
         
-        # Clear History
+        # Clear History (FIXED)
         def clear_audit_trail():
-            audit_manager.execution_history = []
-            audit_manager.incident_history = []
-            audit_manager._initialize_sample_data()
-            return refresh_audit_trail()
+            audit_manager.executions = []
+            audit_manager.incidents = []
+            return audit_manager.get_execution_table(), audit_manager.get_incident_table()
         
         clear_btn.click(
             fn=clear_audit_trail,
-            outputs=[execution_table, incident_table, export_text]
-        )
-        
-        # Export Audit Trail
-        def update_export():
-            return audit_manager.export_audit_trail()
-        
-        export_btn.click(
-            fn=update_export,
-            outputs=[export_text]
-        )
-        
-        # Search similar incidents
-        def search_incidents(query):
-            if not query.strip():
-                return []
-            results = orchestrator.get_similar_incidents(query)
-            return [[r["id"], f"{r['similarity']:.0%}", r["scenario"], r["resolution"]] 
-                    for r in results]
-        
-        search_btn.click(
-            fn=search_incidents,
-            inputs=[search_query],
-            outputs=[search_results]
-        )
-        
-        clear_btn_search.click(
-            fn=lambda: [],
-            outputs=[search_results]
+            outputs=[execution_table, incident_table]
         )
         
-        # Initialize dashboard on load
+        # Initialize with first scenario
         demo.load(
-            fn=lambda: viz_engine.create_executive_dashboard(),
-            outputs=[dashboard_output]
+            fn=lambda: update_scenario("Cache Miss Storm"),
+            outputs=[scenario_description, metrics_display, impact_display,
+                    timeline_output, oss_results, enterprise_results]
         )
     
     return demo
 
 # ===========================================
-# MAIN EXECUTION - CORRECTED
+# MAIN EXECUTION
 # ===========================================
 def main():
-    """Main entry point - CORRECTED"""
+    """Main entry point"""
     print("🚀 Starting ARF Ultimate Investor Demo v3.8.0...")
     print("=" * 70)
     print("📊 Features:")
-    print("  • 5 Comprehensive Tabs with User-Focused Journey")
-    print("  • Live Incident Demo with OSS Analysis")
-    print("  • Business Impact & ROI Calculator")
-    print("  • Audit Trail & History with Memory Graph")
-    print("  • Enterprise Features & License Management")
-    print("  • Learning Engine with Pattern Detection")
+    print("  • 4 Enhanced Incident Scenarios")
+    print("  • Clear OSS vs Enterprise Separation")
+    print("  • Fixed Visualization Engine")
+    print("  • Working Event Handlers")
     print("=" * 70)
-    print(f"\n📦 Using ARF OSS v{OSS_VERSION}")
-    print(f"🔧 ARF Available: {ARF_OSS_AVAILABLE}")
     print("🌐 Opening web interface...")
     
-    # Create and launch the demo interface
     demo = create_demo_interface()
-    
-    # Launch configuration
-    launch_config = {
-        "server_name": "0.0.0.0",
-        "server_port": 7860,
-        "share": False,
-        "debug": False,
-        "show_error": True
-    }
-    
-    demo.launch(**launch_config)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )
 
-# ===========================================
-# EXECUTION GUARD - CORRECTED
-# ===========================================
 if __name__ == "__main__":
     main()