Update app.py

app.py

@@ -1,6 +1,7 @@
 """
-🚀 ARF ULTIMATE INVESTOR DEMO v3.3.7
+🚀 ARF ULTIMATE INVESTOR DEMO v3.3.8
 Enhanced with professional visualizations, export features, and data persistence
+FIXED VERSION: All visualization errors resolved
 """
 
 import asyncio
@@ -122,7 +123,22 @@ class RAGGraphVisualizer:
     def get_graph_figure(self):
         """Create Plotly figure of RAG graph"""
         if not self.incidents:
-            return go.Figure()
+            # Return empty figure with message
+            fig = go.Figure()
+            fig.update_layout(
+                title="🧠 RAG Graph Memory - Learning from Incidents",
+                xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                plot_bgcolor="white",
+                height=500,
+                annotations=[dict(
+                    text="No incidents recorded yet. Try a scenario!",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False,
+                    font=dict(size=16, color="gray")
+                )]
+            )
+            return fig
         
         # Prepare node data
         nodes = []
@@ -241,10 +257,44 @@ class PredictiveVisualizer:
     def get_predictive_timeline(self):
         """Create predictive timeline visualization"""
         if not self.predictions:
-            return go.Figure()
+            # Return empty figure with message
+            fig = go.Figure()
+            fig.update_layout(
+                title="🔮 Predictive Analytics Timeline",
+                xaxis_title="Time",
+                yaxis_title="Metric Value",
+                height=400,
+                plot_bgcolor="white",
+                annotations=[dict(
+                    text="No predictions yet. Try a scenario!",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False,
+                    font=dict(size=14, color="gray")
+                )]
+            )
+            return fig
+        
+        # Create timeline data - ensure we have valid data
+        valid_predictions = []
+        for p in self.predictions[-10:]:  # Last 10 predictions
+            if isinstance(p.get("current"), (int, float)) and isinstance(p.get("predicted"), (int, float)):
+                valid_predictions.append(p)
+        
+        if not valid_predictions:
+            # Return empty figure
+            fig = go.Figure()
+            fig.update_layout(
+                title="🔮 Predictive Analytics Timeline",
+                height=400,
+                annotations=[dict(
+                    text="Waiting for prediction data...",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False
+                )]
+            )
+            return fig
         
-        # Create timeline data
-        df = pd.DataFrame(self.predictions[-10:])  # Last 10 predictions
+        df = pd.DataFrame(valid_predictions)
         
         fig = go.Figure()
         
@@ -270,7 +320,7 @@ class PredictiveVisualizer:
         
         # Add threshold warning if applicable
         for i, row in df.iterrows():
-            if row["time_to_threshold"] and row["time_to_threshold"] < 30:
+            if row["time_to_threshold"] and isinstance(row["time_to_threshold"], (int, float)) and row["time_to_threshold"] < 30:
                 fig.add_annotation(
                     x=row["predicted_at"],
                     y=row["predicted"],
@@ -436,156 +486,266 @@ class LiveDashboard:
         }
 
 # ============================================================================
-# ENHANCED VISUALIZATION ENGINE
+# ENHANCED VISUALIZATION ENGINE - FIXED VERSION
 # ============================================================================
 
 class EnhancedVisualizationEngine:
-    """Enhanced visualization engine with animations and interactivity"""
+    """Enhanced visualization engine with animations and interactivity - FIXED"""
     
     @staticmethod
     def create_animated_radar_chart(metrics: Dict[str, float], title: str = "Performance Radar"):
         """Create animated radar chart with smooth transitions"""
         
-        categories = list(metrics.keys())
-        values = list(metrics.values())
-        
-        # Create radar chart
-        fig = go.Figure()
-        
-        fig.add_trace(go.Scatterpolar(
-            r=values,
-            theta=categories,
-            fill='toself',
-            name='Current',
-            line_color='#4CAF50',
-            opacity=0.8
-        ))
-        
-        # Add ideal baseline (for comparison)
-        baseline_values = [max(values) * 0.8] * len(values)
-        fig.add_trace(go.Scatterpolar(
-            r=baseline_values,
-            theta=categories,
-            fill='toself',
-            name='Ideal Baseline',
-            line_color='#2196F3',
-            opacity=0.3
-        ))
-        
-        fig.update_layout(
-            polar=dict(
-                radialaxis=dict(
-                    visible=True,
-                    range=[0, max(values) * 1.2]
-                )),
-            showlegend=True,
-            title=title,
-            height=400,
-            animations=[{
-                'frame': {'duration': 500, 'redraw': True},
-                'transition': {'duration': 300, 'easing': 'cubic-in-out'},
-            }]
-        )
-        
-        return fig
+        try:
+            # Filter out non-numeric values
+            numeric_metrics = {}
+            for key, value in metrics.items():
+                if isinstance(value, (int, float)):
+                    numeric_metrics[key] = value
+            
+            if not numeric_metrics:
+                # Return empty radar chart
+                fig = go.Figure()
+                fig.update_layout(
+                    title=title,
+                    polar=dict(
+                        radialaxis=dict(visible=True, range=[0, 100])
+                    ),
+                    height=400,
+                    annotations=[dict(
+                        text="No numeric metrics available",
+                        xref="paper", yref="paper",
+                        x=0.5, y=0.5, showarrow=False,
+                        font=dict(size=14, color="gray")
+                    )]
+                )
+                return fig
+            
+            categories = list(numeric_metrics.keys())
+            values = list(numeric_metrics.values())
+            
+            # Ensure we have at least 3 categories for radar chart
+            if len(categories) < 3:
+                # Duplicate categories to make radar work
+                while len(categories) < 3:
+                    categories.append(f"Metric_{len(categories)}")
+                    values.append(0)
+            
+            # Create radar chart
+            fig = go.Figure()
+            
+            fig.add_trace(go.Scatterpolar(
+                r=values,
+                theta=categories,
+                fill='toself',
+                name='Current',
+                line_color='#4CAF50',
+                opacity=0.8
+            ))
+            
+            # Add ideal baseline (for comparison)
+            baseline_values = [max(values) * 0.8] * len(values) if values else [0] * len(categories)
+            fig.add_trace(go.Scatterpolar(
+                r=baseline_values,
+                theta=categories,
+                fill='toself',
+                name='Ideal Baseline',
+                line_color='#2196F3',
+                opacity=0.3
+            ))
+            
+            fig.update_layout(
+                polar=dict(
+                    radialaxis=dict(
+                        visible=True,
+                        range=[0, max(values) * 1.2 if values else 100]
+                    )),
+                showlegend=True,
+                title=title,
+                height=400,
+                animations=[{
+                    'frame': {'duration': 500, 'redraw': True},
+                    'transition': {'duration': 300, 'easing': 'cubic-in-out'},
+                }]
+            )
+            
+            return fig
+        except Exception as e:
+            logging.error(f"Error creating radar chart: {e}")
+            # Return empty figure
+            fig = go.Figure()
+            fig.update_layout(
+                title=title,
+                height=400,
+                annotations=[dict(
+                    text=f"Error loading radar chart",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False,
+                    font=dict(size=14, color="red")
+                )]
+            )
+            return fig
     
     @staticmethod
     def create_heatmap_timeline(scenarios: List[Dict[str, Any]]):
-        """Create heatmap timeline of incidents"""
+        """Create heatmap timeline of incidents - FIXED"""
         
-        # Prepare data
-        severity_map = {"critical": 3, "high": 2, "medium": 1, "low": 0}
-        
-        data = []
-        for i, scenario in enumerate(scenarios):
-            impact = scenario.get("business_impact", {})
-            severity_val = severity_map.get(
-                "critical" if impact.get("revenue_at_risk", 0) > 1000000 else
-                "high" if impact.get("revenue_at_risk", 0) > 500000 else
-                "medium" if impact.get("revenue_at_risk", 0) > 100000 else "low",
-                0
+        try:
+            if not scenarios:
+                # Return empty heatmap
+                fig = go.Figure()
+                fig.update_layout(
+                    title="🔥 Incident Heatmap Timeline",
+                    height=400,
+                    annotations=[dict(
+                        text="No scenario data available",
+                        xref="paper", yref="paper",
+                        x=0.5, y=0.5, showarrow=False,
+                        font=dict(size=14, color="gray")
+                    )]
+                )
+                return fig
+            
+            # Prepare data
+            severity_map = {"critical": 3, "high": 2, "medium": 1, "low": 0}
+            
+            data = []
+            for i, scenario in enumerate(scenarios):
+                impact = scenario.get("business_impact", {})
+                
+                # Safely get severity value
+                revenue_risk = impact.get("revenue_at_risk", 0)
+                if not isinstance(revenue_risk, (int, float)):
+                    revenue_risk = 0
+                
+                severity_val = severity_map.get(
+                    "critical" if revenue_risk > 1000000 else
+                    "high" if revenue_risk > 500000 else
+                    "medium" if revenue_risk > 100000 else "low",
+                    0
+                )
+                
+                description = scenario.get("description", "Unknown")
+                if len(description) > 30:
+                    description = description[:27] + "..."
+                
+                data.append({
+                    "Scenario": description,
+                    "Revenue Risk": revenue_risk,
+                    "Users Impacted": impact.get("users_impacted", 0),
+                    "Severity": severity_val,
+                    "Time to Resolve": impact.get("time_to_resolve", 0),
+                })
+            
+            df = pd.DataFrame(data)
+            
+            # Ensure we have numeric data for heatmap
+            numeric_columns = ['Revenue Risk', 'Users Impacted', 'Severity', 'Time to Resolve']
+            for col in numeric_columns:
+                if col in df.columns:
+                    df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
+            
+            # Create heatmap
+            fig = go.Figure(data=go.Heatmap(
+                z=df[numeric_columns].values.T,
+                x=df['Scenario'],
+                y=numeric_columns,
+                colorscale='RdYlGn_r',  # Red to Green (reversed for severity)
+                showscale=True,
+                hoverongaps=False,
+                hovertemplate='<b>%{x}</b><br>%{y}: %{z}<extra></extra>'
+            ))
+            
+            fig.update_layout(
+                title="🔥 Incident Heatmap Timeline",
+                xaxis_title="Scenarios",
+                yaxis_title="Metrics",
+                height=400,
+                xaxis={'tickangle': 45},
             )
             
-            data.append({
-                "Scenario": scenario.get("description", "Unknown")[:30] + "...",
-                "Revenue Risk": impact.get("revenue_at_risk", 0),
-                "Users Impacted": impact.get("users_impacted", 0),
-                "Severity": severity_val,
-                "Time to Resolve": impact.get("time_to_resolve", 0),
-            })
-        
-        df = pd.DataFrame(data)
-        
-        # Create heatmap
-        fig = go.Figure(data=go.Heatmap(
-            z=df[['Revenue Risk', 'Users Impacted', 'Severity', 'Time to Resolve']].values.T,
-            x=df['Scenario'],
-            y=['Revenue Risk ($)', 'Users Impacted', 'Severity Level', 'Time to Resolve (min)'],
-            colorscale='RdYlGn_r',  # Red to Green (reversed for severity)
-            showscale=True,
-            hoverongaps=False,
-            hovertemplate='<b>%{x}</b><br>%{y}: %{z}<extra></extra>'
-        ))
-        
-        fig.update_layout(
-            title="🔥 Incident Heatmap Timeline",
-            xaxis_title="Scenarios",
-            yaxis_title="Metrics",
-            height=400,
-            xaxis={'tickangle': 45},
-        )
-        
-        return fig
+            return fig
+        except Exception as e:
+            logging.error(f"Error creating heatmap: {e}")
+            # Return empty figure
+            fig = go.Figure()
+            fig.update_layout(
+                title="🔥 Incident Heatmap Timeline",
+                height=400,
+                annotations=[dict(
+                    text=f"Error loading heatmap",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False,
+                    font=dict(size=14, color="red")
+                )]
+            )
+            return fig
     
     @staticmethod
     def create_real_time_metrics_stream():
-        """Create real-time streaming metrics visualization"""
-        
-        # Generate sample streaming data
-        times = pd.date_range(start='now', periods=50, freq='1min')
-        values = np.cumsum(np.random.randn(50)) + 100
-        
-        fig = go.Figure()
+        """Create real-time streaming metrics visualization - FIXED"""
         
-        fig.add_trace(go.Scatter(
-            x=times,
-            y=values,
-            mode='lines+markers',
-            name='System Health Score',
-            line=dict(color='#2196F3', width=3),
-            marker=dict(size=6),
-            hovertemplate='Time: %{x}<br>Score: %{y:.1f}<extra></extra>'
-        ))
-        
-        # Add threshold lines
-        fig.add_hline(y=95, line_dash="dash", line_color="green", 
-                     annotation_text="Optimal", annotation_position="right")
-        fig.add_hline(y=80, line_dash="dash", line_color="orange", 
-                     annotation_text="Warning", annotation_position="right")
-        fig.add_hline(y=70, line_dash="dash", line_color="red", 
-                     annotation_text="Critical", annotation_position="right")
-        
-        # Add range slider
-        fig.update_layout(
-            title="📊 Real-time System Health Monitor",
-            xaxis=dict(
-                rangeselector=dict(
-                    buttons=list([
-                        dict(count=15, label="15m", step="minute", stepmode="backward"),
-                        dict(count=1, label="1h", step="hour", stepmode="backward"),
-                        dict(count=6, label="6h", step="hour", stepmode="backward"),
-                        dict(step="all")
-                    ])
+        try:
+            # Generate sample streaming data
+            times = pd.date_range(start='now', periods=50, freq='1min')
+            values = np.cumsum(np.random.randn(50)) + 100
+            
+            fig = go.Figure()
+            
+            fig.add_trace(go.Scatter(
+                x=times,
+                y=values,
+                mode='lines+markers',
+                name='System Health Score',
+                line=dict(color='#2196F3', width=3),
+                marker=dict(size=6),
+                hovertemplate='Time: %{x}<br>Score: %{y:.1f}<extra></extra>'
+            ))
+            
+            # Add threshold lines
+            fig.add_hline(y=95, line_dash="dash", line_color="green", 
+                         annotation_text="Optimal", annotation_position="right")
+            fig.add_hline(y=80, line_dash="dash", line_color="orange", 
+                         annotation_text="Warning", annotation_position="right")
+            fig.add_hline(y=70, line_dash="dash", line_color="red", 
+                         annotation_text="Critical", annotation_position="right")
+            
+            # Add range slider
+            fig.update_layout(
+                title="📊 Real-time System Health Monitor",
+                xaxis=dict(
+                    rangeselector=dict(
+                        buttons=list([
+                            dict(count=15, label="15m", step="minute", stepmode="backward"),
+                            dict(count=1, label="1h", step="hour", stepmode="backward"),
+                            dict(count=6, label="6h", step="hour", stepmode="backward"),
+                            dict(step="all")
+                        ])
+                    ),
+                    rangeslider=dict(visible=True),
+                    type="date"
                 ),
-                rangeslider=dict(visible=True),
-                type="date"
-            ),
-            yaxis_title="Health Score",
-            height=400,
-            showlegend=True
-        )
-        
-        return fig
+                yaxis_title="Health Score",
+                height=400,
+                showlegend=True
+            )
+            
+            return fig
+        except Exception as e:
+            logging.error(f"Error creating real-time metrics: {e}")
+            # Return empty figure
+            fig = go.Figure()
+            fig.update_layout(
+                title="📊 Real-time System Health Monitor",
+                height=400,
+                annotations=[dict(
+                    text="Loading real-time data...",
+                    xref="paper", yref="paper",
+                    x=0.5, y=0.5, showarrow=False,
+                    font=dict(size=14, color="gray")
+                )]
+            )
+            return fig
 
 # ============================================================================
 # EXPORT ENGINE
@@ -682,7 +842,7 @@ class ExportEngine:
             </table>
             
             <div class="footer">
-                <p>ARF Ultimate Investor Demo v3.3.7 | Generated automatically</p>
+                <p>ARF Ultimate Investor Demo v3.3.8 | Generated automatically</p>
                 <p>Confidential - For investor review only</p>
                 <p>Contact: enterprise@petterjuan.com | Website: https://arf.dev</p>
             </div>
@@ -691,80 +851,6 @@ class ExportEngine:
         """
         
         return html
-    
-    @staticmethod
-    def export_compliance_report(compliance_data: Dict[str, Any], format: str = "html") -> str:
-        """Export compliance report in specified format"""
-        
-        if format == "html":
-            return ExportEngine._compliance_to_html(compliance_data)
-        else:
-            # Return as JSON for other formats
-            return json.dumps(compliance_data, indent=2)
-    
-    @staticmethod
-    def _compliance_to_html(compliance_data: Dict[str, Any]) -> str:
-        """Convert compliance data to HTML report"""
-        
-        html = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>ARF {compliance_data.get('standard', 'Compliance')} Report</title>
-            <style>
-                body {{ font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 40px; }}
-                .header {{ background: linear-gradient(135deg, #2c3e50 0%, #3498db 100%); 
-                         color: white; padding: 30px; border-radius: 10px; margin-bottom: 30px; }}
-                .status-pass {{ color: #27ae60; font-weight: bold; }}
-                .status-fail {{ color: #e74c3c; font-weight: bold; }}
-                .finding-card {{ background: white; border-radius: 8px; padding: 15px; 
-                              margin: 10px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1); 
-                              border-left: 4px solid #3498db; }}
-                .footer {{ margin-top: 40px; padding-top: 20px; border-top: 1px solid #eee; 
-                         color: #666; font-size: 12px; }}
-            </style>
-        </head>
-        <body>
-            <div class="header">
-                <h1>📋 ARF {compliance_data.get('standard', 'Compliance')} Compliance Report</h1>
-                <p>Report ID: {compliance_data.get('report_id', 'N/A')} | 
-                   Generated: {compliance_data.get('generated_at', 'N/A')}</p>
-                <p>Period: {compliance_data.get('period', 'N/A')}</p>
-            </div>
-            
-            <h2>✅ Executive Summary</h2>
-            <div class="finding-card">
-                <h3>{compliance_data.get('summary', 'No summary available')}</h3>
-                <p><strong>Estimated Audit Cost Savings:</strong> {compliance_data.get('estimated_audit_cost_savings', 'N/A')}</p>
-            </div>
-            
-            <h2>🔍 Detailed Findings</h2>
-        """
-        
-        # Add findings
-        findings = compliance_data.get('findings', {})
-        for key, value in findings.items():
-            status_class = "status-pass" if value in [True, "99.95%", "Complete"] else "status-fail"
-            display_value = "✅ PASS" if value is True else "❌ FAIL" if value is False else str(value)
-            
-            html += f"""
-            <div class="finding-card">
-                <h3>{key.replace('_', ' ').title()}</h3>
-                <p class="{status_class}">{display_value}</p>
-            </div>
-            """
-        
-        html += """
-            <div class="footer">
-                <p>This report was automatically generated by ARF Compliance Auditor</p>
-                <p>All findings are based on automated system analysis</p>
-                <p>Contact: enterprise@petterjuan.com | Compliance Hotline: +1-555-COMPLY</p>
-            </div>
-        </body>
-        </html>
-        """
-        
-        return html
 
 # ============================================================================
 # DEMO SCENARIOS - ENHANCED
@@ -898,11 +984,11 @@ ENTERPRISE_SCENARIOS = {
 }
 
 # ============================================================================
-# MAIN DEMO UI - SIMPLIFIED ENHANCED VERSION
+# MAIN DEMO UI - FIXED VERSION
 # ============================================================================
 
 def create_enhanced_demo():
-    """Create enhanced ultimate investor demo UI"""
+    """Create enhanced ultimate investor demo UI - FIXED VERSION"""
     
     # Initialize enhanced components
     business_calc = BusinessImpactCalculator()
@@ -913,9 +999,9 @@ def create_enhanced_demo():
     export_engine = ExportEngine()
     enterprise_servers = {}
     
-    with gr.Blocks(title="🚀 ARF Ultimate Investor Demo v3.3.7") as demo:
+    with gr.Blocks(title="🚀 ARF Ultimate Investor Demo v3.3.8") as demo:
         gr.Markdown("""
-        # 🚀 Agentic Reliability Framework - Ultimate Investor Demo v3.3.7
+        # 🚀 Agentic Reliability Framework - Ultimate Investor Demo v3.3.8
         ### **From Cost Center to Profit Engine: 5.2× ROI with Autonomous Reliability**
         
         <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
@@ -926,7 +1012,7 @@ def create_enhanced_demo():
                     <p style="margin: 5px 0;">Experience the full spectrum: <strong>OSS (Free) ↔ Enterprise (Paid)</strong></p>
                 </div>
                 <div style="text-align: right;">
-                    <p style="margin: 0;">🚀 <strong>v3.3.7</strong> with enhanced visualizations</p>
+                    <p style="margin: 0;">🚀 <strong>v3.3.8</strong> with enhanced visualizations</p>
                     <p style="margin: 0;">📊 Professional analytics & export features</p>
                 </div>
             </div>
@@ -1071,10 +1157,35 @@ def create_enhanced_demo():
                         label="🔮 Predictive Analytics Timeline",
                     )
             
-            # Function to update scenario with enhanced visualization
+            # FIXED: Function to update scenario with enhanced visualization
             def update_scenario_enhanced(scenario_name, viz_type):
                 scenario = ENTERPRISE_SCENARIOS.get(scenario_name, {})
                 
+                # Check if scenario exists
+                if not scenario:
+                    # Return empty figures for all visualizations
+                    empty_fig = go.Figure()
+                    empty_fig.update_layout(
+                        title="No scenario data available",
+                        height=400,
+                        annotations=[dict(
+                            text="Select a valid scenario",
+                            xref="paper", yref="paper",
+                            x=0.5, y=0.5, showarrow=False,
+                            font=dict(size=14, color="gray")
+                        )]
+                    )
+                    
+                    return {
+                        metrics_display: {},
+                        impact_display: {},
+                        rag_graph: rag_visualizer.get_graph_figure(),
+                        predictive_timeline: predictive_viz.get_predictive_timeline(),
+                        performance_chart: empty_fig,
+                        incident_heatmap: empty_fig,
+                        real_time_metrics: viz_engine.create_real_time_metrics_stream(),
+                    }
+                
                 # Add to RAG graph
                 incident_id = rag_visualizer.add_incident(
                     component=scenario.get("component", "unknown"),
@@ -1083,27 +1194,51 @@ def create_enhanced_demo():
                 
                 # Add prediction
                 if "prediction" in scenario:
-                    predictive_viz.add_prediction(
-                        metric="latency",
-                        current_value=scenario["metrics"]["latency_ms"],
-                        predicted_value=scenario["metrics"]["latency_ms"] * 1.3,
-                        time_to_threshold=8.5 if "Black Friday" in scenario_name else None
-                    )
+                    try:
+                        current_val = scenario["metrics"].get("latency_ms", 100)
+                        if isinstance(current_val, (int, float)):
+                            predictive_viz.add_prediction(
+                                metric="latency",
+                                current_value=current_val,
+                                predicted_value=current_val * 1.3,
+                                time_to_threshold=8.5 if "Black Friday" in scenario_name else None
+                            )
+                    except Exception as e:
+                        logging.error(f"Error adding prediction: {e}")
+                
+                # Get impact analysis
+                impact_analysis = {}
+                if "business_impact" in scenario:
+                    impact_analysis = business_calc.calculate_impact(scenario["business_impact"])
                 
                 # Select visualization based on type
-                if viz_type == "Radar Chart":
-                    viz_fig = viz_engine.create_animated_radar_chart(
-                        scenario.get("metrics", {}),
-                        f"Performance Radar - {scenario_name}"
+                try:
+                    if viz_type == "Radar Chart":
+                        viz_fig = viz_engine.create_animated_radar_chart(
+                            scenario.get("metrics", {}),
+                            f"Performance Radar - {scenario_name[:20]}..."
+                        )
+                    elif viz_type == "Heatmap":
+                        viz_fig = viz_engine.create_heatmap_timeline([scenario])
+                    else:  # Stream
+                        viz_fig = viz_engine.create_real_time_metrics_stream()
+                except Exception as e:
+                    logging.error(f"Visualization error: {e}")
+                    viz_fig = go.Figure()
+                    viz_fig.update_layout(
+                        title=f"Visualization for {scenario_name[:20]}...",
+                        height=400,
+                        annotations=[dict(
+                            text="Error loading visualization",
+                            xref="paper", yref="paper",
+                            x=0.5, y=0.5, showarrow=False,
+                            font=dict(size=14, color="red")
+                        )]
                     )
-                elif viz_type == "Heatmap":
-                    viz_fig = viz_engine.create_heatmap_timeline([scenario])
-                else:  # Stream
-                    viz_fig = viz_engine.create_real_time_metrics_stream()
                 
                 return {
                     metrics_display: scenario.get("metrics", {}),
-                    impact_display: business_calc.calculate_impact(scenario.get("business_impact", {})),
+                    impact_display: impact_analysis,
                     rag_graph: rag_visualizer.get_graph_figure(),
                     predictive_timeline: predictive_viz.get_predictive_timeline(),
                     performance_chart: viz_fig,
@@ -1159,11 +1294,12 @@ def create_enhanced_demo():
                 live_dashboard.add_execution_result(result["revenue_protected"])
                 
                 # Add to RAG graph
-                rag_visualizer.add_outcome(
-                    incident_id=f"inc_{len(rag_visualizer.incidents)-1}",
-                    success=result["success"],
-                    action=healing_intent["action"]
-                )
+                if rag_visualizer.incidents:
+                    rag_visualizer.add_outcome(
+                        incident_id=rag_visualizer.incidents[-1]["id"],
+                        success=result["success"],
+                        action=healing_intent["action"]
+                    )
                 
                 # Update dashboard displays
                 dashboard_data = live_dashboard.get_dashboard_data()
@@ -1178,6 +1314,13 @@ def create_enhanced_demo():
                     revenue_protected: f"### 💰 Revenue Protected\n**{dashboard_data['revenue_protected']}**",
                     auto_heal_rate: f"### ⚡ Auto-Heal Rate\n**{dashboard_data['auto_heal_rate']}**",
                     engineer_hours: f"### 👷 Engineer Hours Saved\n**{dashboard_data['engineer_hours_saved']}**",
+                    incident_feed: [[
+                        datetime.datetime.now().strftime("%H:%M:%S"),
+                        scenario.get("component", "unknown"),
+                        f"${result['revenue_protected']:,.0f}",
+                        "✅ Resolved" if result["success"] else "⚠️ Partial",
+                        f"${result['revenue_protected']:,.0f}"
+                    ]],
                 }
             
             # Connect events
@@ -1203,7 +1346,7 @@ def create_enhanced_demo():
             enterprise_action_btn.click(
                 fn=enterprise_execution,
                 inputs=[scenario_selector, license_input, execution_mode],
-                outputs=[result_display, rag_graph, revenue_protected, auto_heal_rate, engineer_hours]
+                outputs=[result_display, rag_graph, revenue_protected, auto_heal_rate, engineer_hours, incident_feed]
             )
         
         # ================================================================
@@ -1413,6 +1556,14 @@ def create_enhanced_demo():
                 mttr_reduction = 0.94  # 94% faster
                 engineer_time_savings = 0.85  # 85% less engineer time
                 
+                # Ensure numeric values
+                try:
+                    incidents = float(incidents) if incidents else 0
+                    team_size = float(team_size) if team_size else 0
+                    incident_cost = float(incident_cost) if incident_cost else 0
+                except:
+                    incidents = team_size = incident_cost = 0
+                
                 # Calculations
                 manual_incidents = incidents * (1 - auto_heal_rate)
                 auto_healed = incidents * auto_heal_rate
@@ -1434,7 +1585,7 @@ def create_enhanced_demo():
                 
                 # ROI
                 payback_months = implementation_cost / monthly_savings if monthly_savings > 0 else 999
-                first_year_roi = ((annual_savings - implementation_cost) / implementation_cost) * 100
+                first_year_roi = ((annual_savings - implementation_cost) / implementation_cost) * 100 if implementation_cost > 0 else 0
                 
                 # Create chart
                 fig = go.Figure(data=[
@@ -1505,7 +1656,7 @@ def create_enhanced_demo():
         </div>
         
         <div style="text-align: center; padding: 15px; background: #2c3e50; color: white; border-radius: 5px; margin-top: 20px;">
-            <p style="margin: 0;">🚀 ARF Ultimate Investor Demo v3.3.7 | Enhanced with Professional Analytics & Export Features</p>
+            <p style="margin: 0;">🚀 ARF Ultimate Investor Demo v3.3.8 | Enhanced with Professional Analytics & Export Features</p>
             <p style="margin: 5px 0 0 0; font-size: 12px;">Built with ❤️ using Gradio & Plotly</p>
         </div>
         """)
@@ -1522,7 +1673,7 @@ def main():
     logger = logging.getLogger(__name__)
     
     logger.info("=" * 80)
-    logger.info("🚀 Starting ARF Ultimate Investor Demo v3.3.7")
+    logger.info("🚀 Starting ARF Ultimate Investor Demo v3.3.8")
     logger.info("=" * 80)
     
     demo = create_enhanced_demo()