Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,4 +1,4 @@
-#Complete Yazaki India Ltd version - Full Feature Set
+#Stable version for Yazaki India Ltd - Same structure as Rane demo
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -15,7 +15,7 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Complete Custom CSS
+# Custom CSS (same as original)
 st.markdown("""
 <style>
     .main-header {
@@ -60,38 +60,6 @@ st.markdown("""
         border-radius: 8px;
         margin: 0.5rem 0;
     }
-    
-    .supplier-card {
-        background: white;
-        border: 1px solid #e0e0e0;
-        border-radius: 10px;
-        padding: 1rem;
-        margin: 0.5rem 0;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-    }
-    
-    .mitigation-card {
-        background: #f0f8ff;
-        border: 1px solid #2196f3;
-        border-radius: 8px;
-        padding: 1rem;
-        margin: 0.5rem 0;
-    }
-    
-    .external-signal {
-        background: white;
-        border-radius: 8px;
-        padding: 0.8rem;
-        margin: 0.5rem 0;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-    }
-    
-    .stMetric {
-        background: white;
-        padding: 1rem;
-        border-radius: 8px;
-        border: 1px solid #e0e0e0;
-    }
 </style>
 """, unsafe_allow_html=True)
 
@@ -100,12 +68,8 @@ if 'executed_mitigations' not in st.session_state:
     st.session_state.executed_mitigations = []
 if 'external_signals' not in st.session_state:
     st.session_state.external_signals = []
-if 'buffer_settings' not in st.session_state:
-    st.session_state.buffer_settings = {}
-if 'alert_history' not in st.session_state:
-    st.session_state.alert_history = []
 
-# COMPLETE: Generate 8-week forward-looking demand data for Yazaki
+# Generate 8-week forward-looking demand data for Yazaki
 @st.cache_data
 def generate_8week_demand_data():
     today = datetime(2025, 8, 4)
@@ -114,75 +78,47 @@ def generate_8week_demand_data():
     # Yazaki-specific materials (wire harnesses, connectors, electrical components)
     materials = [
         'WH001-Engine Wire Harness',
-        'WH002-Dashboard Wire Harness', 
-        'WH003-Door Wire Harness',
+        'WH002-Dashboard Wire Harness',
         'CON001-Electrical Connector',
-        'CON002-Multi-Pin Connector',
         'TER001-Wire Terminal',
-        'TER002-Crimp Terminal',
-        'FUS001-Fuse Box Assembly',
-        'REL001-Relay Module',
-        'SWI001-Switch Assembly'
+        'FUS001-Fuse Box Assembly'
     ]
     
     all_data = []
     for material in materials:
         np.random.seed(hash(material) % 1000)
         
-        # Generate sophisticated demand patterns
+        # Generate base demand patterns
         base_demand = np.random.normal(150, 15, 56)
         
-        # First 14 days: FIRM DEMAND with customer confirmed orders
+        # First 14 days: FIRM DEMAND
         firm_demand = np.clip(base_demand[:14], 100, 200).astype(int)
         
-        # Days 15-56: Customer shared demand (tentative forecasts)
+        # Days 15-56: Customer shared demand (tentative)
         customer_shared = np.clip(base_demand[14:] * (1 + 0.05 * np.sin(np.linspace(0, 3.14, 42))), 80, 220).astype(int)
         
-        # Days 15-56: AI-corrected demand (with external signals and market intelligence)
+        # Days 15-56: AI-corrected demand (with external signals)
         external_factors = np.zeros(42)
-        
-        # Weather impact (weeks 3-4) - affects logistics and supplier operations
+        # Weather impact (weeks 3-4)
         external_factors[0:14] += np.random.normal(0, 5, 14)
-        
-        # EV policy impact (weeks 5-8) - higher for wire harnesses due to EV complexity
+        # EV policy impact (weeks 5-8) - higher for wire harnesses
         if 'WH' in material:
-            external_factors[14:] += 15  # Higher impact for wire harnesses in EVs
+            external_factors[14:] += 12  # Higher impact for wire harnesses in EVs
         elif 'CON' in material or 'TER' in material:
-            external_factors[14:] += 10  # Moderate impact for connectors/terminals
-        elif 'REL' in material or 'SWI' in material:
-            external_factors[14:] += 8   # Lower impact for relays/switches
-        
-        # Festive season automotive demand boost (weeks 6-7)
-        external_factors[28:42] += np.random.normal(12, 3, 14)
-        
-        # Supply chain disruption factors (global chip shortage impact)
-        if 'FUS' in material or 'REL' in material:
-            external_factors[21:35] += 6  # Electronic components more affected
-        
-        # Market sentiment and new model launches
-        external_factors[35:42] += np.random.normal(5, 2, 7)
+            external_factors[14:] += 8   # Moderate impact for connectors/terminals
+        # Festive season boost (weeks 6-7)
+        external_factors[28:42] += 8
         
-        corrected_demand = np.clip(customer_shared + external_factors, 60, 280).astype(int)
+        corrected_demand = np.clip(customer_shared + external_factors, 60, 250).astype(int)
         
-        # Generate comprehensive supply plan for 56 days
-        base_supply_capacity = 155 + (hash(material) % 40) - 20  # Vary by material
-        supply_capacity = np.random.normal(base_supply_capacity, 12, 56)
-        supply_plan = np.clip(supply_capacity, 120, 250).astype(int)
+        # Generate supply plan for 56 days
+        supply_capacity = np.random.normal(155, 12, 56)
+        supply_plan = np.clip(supply_capacity, 120, 220).astype(int)
         
-        # Apply realistic disruptions to supply
+        # Apply disruptions to supply (weather impact on days 15-18)
         supply_actual = supply_plan.copy()
+        supply_actual[15:19] = (supply_actual[15:19] * 0.8).astype(int)
         
-        # Weather-related supply disruption (Chennai monsoons, days 15-18)
-        supply_actual[15:19] = (supply_actual[15:19] * 0.75).astype(int)
-        
-        # Tier-2 supplier quality issue (days 25-27)
-        if 'CON' in material:
-            supply_actual[25:28] = (supply_actual[25:28] * 0.6).astype(int)
-        
-        # Transportation strike impact (days 35-37)
-        supply_actual[35:38] = (supply_actual[35:38] * 0.8).astype(int)
-        
-        # Generate additional metrics
         for i, date in enumerate(dates):
             # Determine which demand to use
             if i < 14:
@@ -198,29 +134,14 @@ def generate_8week_demand_data():
                 corrected_val = corrected_demand[i-14]
                 demand_type = "AI-Corrected"
             
-            # Calculate comprehensive metrics
+            # Calculate shortfall
             shortfall = max(0, demand_used - supply_actual[i])
-            excess = max(0, supply_actual[i] - demand_used)
-            fill_rate = min(100, (supply_actual[i] / demand_used) * 100) if demand_used > 0 else 100
-            
-            # Risk scoring
-            risk_score = 0
-            if shortfall > 0:
-                risk_score += (shortfall / demand_used) * 40 if demand_used > 0 else 20
-            if i >= 15 and i <= 18:  # Weather disruption period
-                risk_score += 15
-            if demand_type == "AI-Corrected" and corrected_val and customer_val:
-                if corrected_val > customer_val * 1.2:  # High demand correction
-                    risk_score += 10
-            
-            risk_level = "Critical" if risk_score >= 50 else "High" if risk_score >= 30 else "Medium" if risk_score >= 15 else "Low"
             
             all_data.append({
                 'Date': date,
                 'Week': f"Week {(i//7)+1}",
                 'Day': i + 1,
                 'Material': material,
-                'Material_Category': material.split('-')[0],
                 'Firm_Demand': firm_val,
                 'Customer_Demand': customer_val,
                 'Corrected_Demand': corrected_val,
@@ -228,80 +149,43 @@ def generate_8week_demand_data():
                 'Supply_Plan': supply_plan[i],
                 'Supply_Projected': supply_actual[i],
                 'Shortfall': shortfall,
-                'Excess': excess,
-                'Fill_Rate': round(fill_rate, 1),
                 'Demand_Type': demand_type,
-                'Gap': supply_actual[i] - demand_used,
-                'Risk_Score': round(risk_score, 1),
-                'Risk_Level': risk_level,
-                'Week_Number': (i//7)+1
+                'Gap': supply_actual[i] - demand_used
             })
     
     return pd.DataFrame(all_data)
 
-# COMPLETE Yazaki-specific Tier-2 suppliers with detailed information
+# Yazaki-specific Tier-2 suppliers
 @st.cache_data
 def get_tier2_suppliers():
     return {
-        'Furukawa Electric India Pvt Ltd': {
-            'location': 'Chennai, Tamil Nadu',
-            'materials': ['WH001-Engine Wire Harness', 'WH002-Dashboard Wire Harness', 'WH003-Door Wire Harness'],
-            'capacity': 220,
-            'reliability': 96,
+        'Furukawa Electric India': {
+            'location': 'Chennai',
+            'materials': ['WH001-Engine Wire Harness', 'WH002-Dashboard Wire Harness'],
+            'capacity': 200,
+            'reliability': 95,
             'lead_time': 2,
-            'risk_factors': ['Monsoon flooding', 'Port congestion Chennai', 'Copper price volatility', 'Power grid instability'],
-            'tier_level': 'Tier-2',
-            'certifications': ['ISO 9001', 'TS 16949', 'ISO 14001'],
-            'financial_health': 'Strong',
-            'backup_available': True,
-            'contract_type': 'Long-term',
-            'performance_rating': 4.8
+            'risk_factors': ['Monsoon flooding', 'Port congestion', 'Copper price volatility']
         },
-        'Sumitomo Wiring Systems India': {
-            'location': 'Bangalore, Karnataka',
-            'materials': ['CON001-Electrical Connector', 'CON002-Multi-Pin Connector', 'TER001-Wire Terminal', 'TER002-Crimp Terminal'],
-            'capacity': 200,
-            'reliability': 94,
+        'Sumitomo Wiring Systems': {
+            'location': 'Bangalore',
+            'materials': ['CON001-Electrical Connector', 'TER001-Wire Terminal'],
+            'capacity': 180,
+            'reliability': 92,
             'lead_time': 3,
-            'risk_factors': ['Transportation delays NH4', 'Raw material shortage', 'Equipment aging', 'Skilled labor shortage'],
-            'tier_level': 'Tier-2',
-            'certifications': ['ISO 9001', 'TS 16949'],
-            'financial_health': 'Stable',
-            'backup_available': True,
-            'contract_type': 'Medium-term',
-            'performance_rating': 4.6
+            'risk_factors': ['Transportation delays', 'Raw material shortage', 'Equipment failure']
         },
         'JST India Private Limited': {
-            'location': 'Pune, Maharashtra',
-            'materials': ['FUS001-Fuse Box Assembly', 'CON001-Electrical Connector', 'REL001-Relay Module'],
-            'capacity': 180,
-            'reliability': 91,
+            'location': 'Pune',
+            'materials': ['FUS001-Fuse Box Assembly', 'CON001-Electrical Connector'],
+            'capacity': 220,
+            'reliability': 88,
             'lead_time': 1,
-            'risk_factors': ['Quality consistency issues', 'Capacity constraints', 'Supplier payment disputes', 'Mumbai port dependency'],
-            'tier_level': 'Tier-2',
-            'certifications': ['ISO 9001', 'TS 16949', 'UL Listed'],
-            'financial_health': 'Moderate',
-            'backup_available': False,
-            'contract_type': 'Short-term',
-            'performance_rating': 4.2
-        },
-        'Motherson Sumi Infotech & Designs': {
-            'location': 'Noida, Uttar Pradesh',
-            'materials': ['SWI001-Switch Assembly', 'REL001-Relay Module', 'FUS001-Fuse Box Assembly'],
-            'capacity': 160,
-            'reliability': 89,
-            'lead_time': 4,
-            'risk_factors': ['Delhi NCR pollution restrictions', 'Highway congestion', 'Seasonal workforce fluctuation'],
-            'tier_level': 'Tier-2',
-            'certifications': ['ISO 9001', 'TS 16949'],
-            'financial_health': 'Stable',
-            'backup_available': True,
-            'contract_type': 'Long-term',
-            'performance_rating': 4.4
+            'risk_factors': ['Quality issues', 'Capacity constraints', 'Supplier disputes']
         }
     }
 
-# COMPLETE ecosystem generation with advanced modeling
+# Generate ecosystem data
 @st.cache_data
 def generate_ecosystem_data():
     today = datetime(2025, 8, 4)
@@ -314,1496 +198,496 @@ def generate_ecosystem_data():
             np.random.seed(hash(supplier_name + material) % 1000)
             
             base_capacity = supplier_info['capacity']
-            reliability_factor = supplier_info['reliability'] / 100
-            
-            # Generate normal supply with reliability variation
-            normal_supply = np.random.normal(base_capacity * reliability_factor, base_capacity * 0.05, 14).astype(int)
-            normal_supply = np.clip(normal_supply, base_capacity * 0.8, base_capacity * 1.1).astype(int)
-            
+            normal_supply = np.full(14, base_capacity, dtype=int)
             disrupted_supply = normal_supply.copy()
             
-            # Apply realistic disruptions based on supplier profiles
-            if supplier_name == 'Furukawa Electric India Pvt Ltd':
-                # Chennai monsoon disruption days 3-6
-                disrupted_supply[3:7] = (disrupted_supply[3:7] * 0.25).astype(int)
-                disruption_cause = "Severe monsoon flooding in Chennai affecting production and logistics"
+            if supplier_name == 'Furukawa Electric India':
+                disrupted_supply[3:7] = (disrupted_supply[3:7] * 0.3).astype(int)
+                disruption_cause = "Monsoon flooding in Chennai"
                 disruption_days = list(range(3, 7))
-                disruption_severity = "Critical"
-            elif supplier_name == 'Sumitomo Wiring Systems India':
-                # Equipment failure days 5-7
-                disrupted_supply[5:8] = (disrupted_supply[5:8] * 0.45).astype(int)
-                disruption_cause = "Critical injection molding equipment failure - spare parts delayed"
+            elif supplier_name == 'Sumitomo Wiring Systems':
+                disrupted_supply[5:8] = (disrupted_supply[5:8] * 0.5).astype(int)
+                disruption_cause = "Critical equipment failure"
                 disruption_days = list(range(5, 8))
-                disruption_severity = "High"
             elif supplier_name == 'JST India Private Limited':
-                # Labor strike days 8-10
-                disrupted_supply[8:11] = (disrupted_supply[8:11] * 0.15).astype(int)
-                disruption_cause = "Unplanned labor strike at Pune facility over wage negotiations"
+                disrupted_supply[8:11] = (disrupted_supply[8:11] * 0.2).astype(int)
+                disruption_cause = "Labor strike at Pune facility"
                 disruption_days = list(range(8, 11))
-                disruption_severity = "Critical"
-            elif supplier_name == 'Motherson Sumi Infotech & Designs':
-                # Transportation delays days 6-8
-                disrupted_supply[6:9] = (disrupted_supply[6:9] * 0.7).astype(int)
-                disruption_cause = "Highway blockage on Delhi-Noida route due to farmer protests"
-                disruption_days = list(range(6, 9))
-                disruption_severity = "Medium"
             else:
-                disruption_cause = "Normal Operations"
+                disruption_cause = "No disruption"
                 disruption_days = []
-                disruption_severity = "None"
             
             lead_time = supplier_info['lead_time']
-            yazaki_supply = normal_supply.copy()
+            yazaki_supply = np.full(14, base_capacity, dtype=int)
             
-            # Calculate cascading impact on Yazaki with lead time consideration
             for disruption_day in disruption_days:
                 arrival_day = disruption_day + lead_time
                 if arrival_day < 14:
                     reduction = normal_supply[disruption_day] - disrupted_supply[disruption_day]
                     yazaki_supply[arrival_day] = max(yazaki_supply[arrival_day] - reduction, 0)
             
-            # Calculate financial impact
-            unit_cost = 100 + (hash(material) % 200)  # Simulate unit costs
-            
             for i, date in enumerate(dates):
-                tier2_impact = int(normal_supply[i] - disrupted_supply[i])
-                yazaki_impact = int(normal_supply[i] - yazaki_supply[i])
-                financial_impact = yazaki_impact * unit_cost
-                
-                # Recovery timeline estimation
-                if i in disruption_days:
-                    days_to_recover = len(disruption_days) + lead_time
-                else:
-                    days_to_recover = 0
-                
                 all_data.append({
                     'Date': date,
                     'Supplier': supplier_name,
                     'Material': material,
-                    'Supplier_Location': supplier_info['location'],
                     'Tier2_Normal_Supply': int(normal_supply[i]),
                     'Tier2_Disrupted_Supply': int(disrupted_supply[i]),
-                    'Tier2_Impact': tier2_impact,
+                    'Tier2_Impact': int(normal_supply[i] - disrupted_supply[i]),
                     'Yazaki_Normal_Supply': int(normal_supply[i]),
                     'Yazaki_Impacted_Supply': int(yazaki_supply[i]),
-                    'Yazaki_Impact': yazaki_impact,
-                    'Financial_Impact_INR': financial_impact,
+                    'Yazaki_Impact': int(normal_supply[i] - yazaki_supply[i]),
                     'Disruption_Cause': disruption_cause if i in disruption_days else "Normal Operations",
-                    'Disruption_Severity': disruption_severity if i in disruption_days else "None",
                     'Lead_Time_Days': lead_time,
                     'Is_Disrupted': i in disruption_days,
-                    'Is_Yazaki_Impacted': yazaki_supply[i] < normal_supply[i],
-                    'Recovery_Timeline_Days': days_to_recover if i in disruption_days else 0,
-                    'Supplier_Reliability': supplier_info['reliability'],
-                    'Backup_Available': supplier_info['backup_available'],
-                    'Performance_Rating': supplier_info['performance_rating']
+                    'Is_Yazaki_Impacted': yazaki_supply[i] < normal_supply[i]
                 })
     
     return pd.DataFrame(all_data)
 
-# COMPLETE external signals with advanced market intelligence
+# Updated external signals for Yazaki
 @st.cache_data
 def get_external_signals():
     return [
-        {
-            'Source': 'Weather API (IMD)',
-            'Signal': 'Heavy to very heavy rainfall forecasted in Chennai and surrounding areas for next 72 hours',
-            'Impact': 'Supply Chain Risk',
-            'Confidence': 97,
-            'Urgency': 'Immediate',
-            'Affected_Materials': ['WH001', 'WH002', 'WH003'],
-            'Estimated_Impact': '60-80% production reduction',
-            'Timeline': '3-5 days',
-            'Mitigation_Available': True
-        },
-        {
-            'Source': 'Market Intelligence (Automotive)',
-            'Signal': 'EV sales in India increased by 32% this quarter - Tata Motors, Mahindra leading growth',
-            'Impact': 'Demand Surge',
-            'Confidence': 91,
-            'Urgency': 'High',
-            'Affected_Materials': ['WH001', 'WH002', 'CON001', 'REL001'],
-            'Estimated_Impact': '25-30% demand increase',
-            'Timeline': '4-6 weeks',
-            'Mitigation_Available': True
-        },
-        {
-            'Source': 'News Analytics (Economic)',
-            'Signal': 'Upcoming festive season (Diwali, Dussehra) - historical data shows 18% automotive demand spike',
-            'Impact': 'Seasonal Demand Peak',
-            'Confidence': 94,
-            'Urgency': 'Medium',
-            'Affected_Materials': ['All'],
-            'Estimated_Impact': '15-20% demand increase',
-            'Timeline': '6-8 weeks',
-            'Mitigation_Available': True
-        },
-        {
-            'Source': 'Supplier Network (Tier-1)',
-            'Signal': 'Sumitomo expanding connector manufacturing capacity by 25% at Bangalore facility',
-            'Impact': 'Supply Capacity Boost',
-            'Confidence': 99,
-            'Urgency': 'Low',
-            'Affected_Materials': ['CON001', 'CON002', 'TER001', 'TER002'],
-            'Estimated_Impact': '+25% supply capacity',
-            'Timeline': '2-3 weeks',
-            'Mitigation_Available': False
-        },
-        {
-            'Source': 'Social Media Analytics',
-            'Signal': 'Highly positive consumer sentiment for new Maruti Suzuki and Hyundai EV models on social platforms',
-            'Impact': 'Potential Demand Growth',
-            'Confidence': 78,
-            'Urgency': 'Medium',
-            'Affected_Materials': ['WH001', 'WH002', 'CON001'],
-            'Estimated_Impact': '8-12% demand growth',
-            'Timeline': '3-4 weeks',
-            'Mitigation_Available': True
-        },
-        {
-            'Source': 'Government Portal (MoRTH)',
-            'Signal': 'New EV subsidy scheme (FAME III) approved - ₹15,000 additional subsidy per vehicle',
-            'Impact': 'Market Expansion',
-            'Confidence': 100,
-            'Urgency': 'High',
-            'Affected_Materials': ['All EV-related components'],
-            'Estimated_Impact': '40-50% EV segment growth',
-            'Timeline': '1-2 weeks implementation',
-            'Mitigation_Available': True
-        },
-        {
-            'Source': 'Logistics Intelligence',
-            'Signal': 'NH4 highway construction causing 2-hour average delays for Bangalore-Chennai route',
-            'Impact': 'Transportation Delays',
-            'Confidence': 88,
-            'Urgency': 'Medium',
-            'Affected_Materials': ['CON001', 'CON002', 'TER001', 'TER002'],
-            'Estimated_Impact': '1-2 days delivery delays',
-            'Timeline': '4-6 weeks (construction period)',
-            'Mitigation_Available': True
-        },
-        {
-            'Source': 'Financial Markets',
-            'Signal': 'Copper prices increased 8% this week due to global supply concerns',
-            'Impact': 'Cost Inflation',
-            'Confidence': 95,
-            'Urgency': 'High',
-            'Affected_Materials': ['WH001', 'WH002', 'WH003'],
-            'Estimated_Impact': '5-8% material cost increase',
-            'Timeline': 'Immediate',
-            'Mitigation_Available': False
-        }
+        {'Source': 'Weather API', 'Signal': 'Heavy rains forecasted in Chennai for next 3 days', 'Impact': 'Supply Risk', 'Confidence': 95},
+        {'Source': 'Market Intelligence', 'Signal': 'EV sales up 25% this quarter - increased wire harness demand', 'Impact': 'Demand Increase', 'Confidence': 88},
+        {'Source': 'News Analytics', 'Signal': 'Upcoming festive season - historically 15% automotive demand spike', 'Impact': 'Demand Surge', 'Confidence': 92},
+        {'Source': 'Supplier Network', 'Signal': 'Tier-2 connector supplier capacity increased by 20%', 'Impact': 'Supply Boost', 'Confidence': 98},
+        {'Source': 'Social Media', 'Signal': 'Positive sentiment around new Tata EV models', 'Impact': 'Demand Growth', 'Confidence': 75},
+        {'Source': 'Government Portal', 'Signal': 'New EV subsidy policy effective next week', 'Impact': 'Market Expansion', 'Confidence': 100}
     ]
 
-# COMPLETE alert generation with sophisticated logic
+# Generate alerts for 8-week data
 def generate_detailed_alerts(df):
     alerts = []
     for material in df['Material'].unique():
         material_data = df[df['Material'] == material]
-        
-        # Identify various types of alerts
         shortage_days = material_data[material_data['Shortfall'] > 5]
-        high_risk_days = material_data[material_data['Risk_Score'] >= 30]
-        low_fill_rate_days = material_data[material_data['Fill_Rate'] < 85]
         
-        # Process shortage alerts
-        for _, row in shortage_days.iterrows():
-            root_causes = []
-            
-            if row['Day'] > 14:
-                if row['Corrected_Demand'] and row['Customer_Demand']:
-                    diff = row['Corrected_Demand'] - row['Customer_Demand']
-                    if diff > 10:
-                        root_causes.append(f"AI detected {diff} units additional demand from market signals")
-                        root_causes.append("External factors: EV policy impact, festive season, market sentiment")
+        if not shortage_days.empty:
+            for _, row in shortage_days.iterrows():
+                root_causes = []
                 
-                if row['Day'] >= 15 and row['Day'] <= 18:
-                    root_causes.append("Chennai monsoon disruption affecting Furukawa Electric supply chain")
-                elif row['Day'] >= 25 and row['Day'] <= 27:
-                    root_causes.append("Quality issues at Tier-2 connector supplier affecting production")
-                elif row['Day'] >= 35 and row['Day'] <= 37:
-                    root_causes.append("Transportation strike impact on material deliveries")
-            else:
-                root_causes.append("Firm customer demand exceeding current supply capacity")
-                root_causes.append("Insufficient safety stock buffer for confirmed orders")
-            
-            if not root_causes:
-                root_causes.append("Base demand variability exceeding supply flexibility")
-            
-            # Advanced mitigation options with detailed impact analysis
-            mitigation_options = [
-                {
-                    "option": "Activate Aurangabad backup production facility",
-                    "impact": f"+{int(row['Shortfall'] * 0.8)} units/day",
-                    "cost": "High (₹2.5L/day operational cost)",
-                    "timeline": "18-24 hours",
-                    "success_probability": "90%",
-                    "resource_requirements": "15 additional staff, equipment setup"
-                },
-                {
-                    "option": "Emergency air freight from Yazaki Philippines plant",
-                    "impact": f"+{int(row['Shortfall'] * 1.2)} units/day",
-                    "cost": "Very High (₹8-12/unit logistics premium)",
-                    "timeline": "4-6 hours",
-                    "success_probability": "95%",
-                    "resource_requirements": "Customs clearance, quality verification"
-                },
-                {
-                    "option": "Expedite Tier-2 supplier overtime production",
-                    "impact": f"+{int(row['Shortfall'] * 0.6)} units/day",
-                    "cost": "Medium (25% overtime premium)",
-                    "timeline": "8-12 hours",
-                    "success_probability": "85%",
-                    "resource_requirements": "Supplier capacity confirmation, quality assurance"
-                },
-                {
-                    "option": "Reallocate inventory from Chennai/Bangalore Yazaki plants",
-                    "impact": f"+{int(row['Shortfall'] * 0.5)} units/day",
-                    "cost": "Low (₹500/unit transfer cost)",
-                    "timeline": "12-18 hours",
-                    "success_probability": "75%",
-                    "resource_requirements": "Inter-plant coordination, transportation"
-                },
-                {
-                    "option": "Activate alternate supplier (backup vendor network)",
-                    "impact": f"+{int(row['Shortfall'] * 0.7)} units/day",
-                    "cost": "High (15-20% unit cost premium)",
-                    "timeline": "24-36 hours",
-                    "success_probability": "80%",
-                    "resource_requirements": "Quality qualification, contract negotiation"
-                }
-            ]
-            
-            # Intelligent best option selection
-            if row['Shortfall'] > 40:
-                best_option = mitigation_options[1]  # Emergency air freight
-                secondary_option = mitigation_options[0]  # Backup production
-            elif row['Shortfall'] > 25:
-                best_option = mitigation_options[0]  # Backup production
-                secondary_option = mitigation_options[4]  # Alternate supplier
-            elif row['Shortfall'] > 15:
-                best_option = mitigation_options[2]  # Overtime production
-                secondary_option = mitigation_options[3]  # Inventory reallocation
-            else:
-                best_option = mitigation_options[3]  # Inventory reallocation
-                secondary_option = mitigation_options[2]  # Overtime production
-            
-            # Calculate business impact
-            revenue_at_risk = row['Shortfall'] * 250  # Assume ₹250 revenue per unit
-            customer_impact = "High" if row['Shortfall'] > 30 else "Medium" if row['Shortfall'] > 15 else "Low"
-            
-            alerts.append({
-                'alert_id': f"ALERT-{material.split('-')[0]}-{row['Day']:02d}",
-                'material': material,
-                'date': row['Date'].strftime('%Y-%m-%d'),
-                'week': row['Week'],
-                'shortage': int(row['Shortfall']),
-                'demand_type': row['Demand_Type'],
-                'severity': row['Risk_Level'],
-                'fill_rate': row['Fill_Rate'],
-                'risk_score': row['Risk_Score'],
-                'root_causes': root_causes,
-                'mitigation_options': mitigation_options,
-                'best_option': best_option,
-                'secondary_option': secondary_option,
-                'revenue_at_risk': revenue_at_risk,
-                'customer_impact': customer_impact,
-                'generated_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-            })
-    
-    # Sort alerts by severity and shortage amount
-    severity_order = {'Critical': 4, 'High': 3, 'Medium': 2, 'Low': 1}
-    alerts.sort(key=lambda x: (severity_order.get(x['severity'], 0), x['shortage']), reverse=True)
+                if row['Day'] > 14:
+                    if row['Corrected_Demand'] and row['Customer_Demand']:
+                        diff = row['Corrected_Demand'] - row['Customer_Demand']
+                        if diff > 10:
+                            root_causes.append(f"AI detected {diff} units additional demand from external signals")
+                    
+                    if row['Day'] >= 15 and row['Day'] <= 18:
+                        root_causes.append("Chennai plant weather disruption reducing supply")
+                else:
+                    root_causes.append("Firm demand exceeding supply capacity")
+                
+                if not root_causes:
+                    root_causes.append("Base demand exceeding current supply capacity")
+                
+                mitigation_options = [
+                    {"option": "Activate Aurangabad backup production", "impact": "+30 units/day", "cost": "High", "timeline": "24 hours"},
+                    {"option": "Expedite Tier-2 supplier shipments", "impact": "+15 units/day", "cost": "Medium", "timeline": "12 hours"},
+                    {"option": "Emergency air freight from Yazaki Philippines", "impact": "+40 units/day", "cost": "Very High", "timeline": "6 hours"},
+                    {"option": "Reallocate inventory from other Yazaki plants", "impact": "+20 units/day", "cost": "Low", "timeline": "18 hours"}
+                ]
+                
+                if row['Shortfall'] > 30:
+                    best_option = mitigation_options[2]
+                elif row['Shortfall'] > 15:
+                    best_option = mitigation_options[0]
+                else:
+                    best_option = mitigation_options[1]
+                
+                alerts.append({
+                    'material': material,
+                    'date': row['Date'].strftime('%Y-%m-%d'),
+                    'week': row['Week'],
+                    'shortage': int(row['Shortfall']),
+                    'demand_type': row['Demand_Type'],
+                    'severity': 'Critical' if row['Shortfall'] > 30 else 'High' if row['Shortfall'] > 15 else 'Medium',
+                    'root_causes': root_causes,
+                    'mitigation_options': mitigation_options,
+                    'best_option': best_option
+                })
     
     return alerts
 
-# COMPLETE mitigation strategies with advanced modeling
+# Mitigation strategies with Yazaki-specific updates
 def generate_mitigation_strategies(supplier, material, impact_amount, impact_days):
     base_strategies = [
         {
-            'strategy': 'Activate Primary Alternate Supplier',
-            'description': f'Engage pre-qualified backup supplier for {material}',
-            'timeline': '18-24 hours',
-            'cost': 'High (+18% unit cost, ₹50K setup)',
-            'effectiveness': '92%',
-            'capacity': f'+{impact_amount * 0.92:.0f} units/day',
-            'risks': ['Quality variation risk', 'Initial delivery delays'],
-            'prerequisites': ['Supplier audit completion', 'Quality agreement'],
-            'resource_allocation': 'Supply chain team: 3 FTE for 48 hours'
-        },
-        {
-            'strategy': 'Emergency Air Freight from Global Network',
-            'description': f'Air freight {material} from Yazaki Philippines/Thailand facilities',
-            'timeline': '4-8 hours',
-            'cost': 'Very High (+45% logistics cost, ₹15/unit)',
-            'effectiveness': '88%',
-            'capacity': f'+{impact_amount * 0.88:.0f} units/day',
-            'risks': ['Customs delays', 'Weather disruptions'],
-            'prerequisites': ['Export/import licenses', 'Quality certificates'],
-            'resource_allocation': 'Logistics team: 2 FTE, Customs agent'
+            'strategy': 'Activate Alternate Supplier',
+            'description': f'Engage backup supplier for {material}',
+            'timeline': '24-48 hours',
+            'cost': 'High (+15% unit cost)',
+            'effectiveness': '90%',
+            'capacity': f'+{impact_amount * 0.9:.0f} units/day',
         },
         {
-            'strategy': 'Inter-Plant Inventory Reallocation',
-            'description': f'Reallocate {material} inventory from Chennai/Bangalore plants',
-            'timeline': '8-16 hours',
-            'cost': 'Medium (+8% handling cost, ₹5K transport)',
+            'strategy': 'Emergency Air Freight',
+            'description': f'Air freight {material} from Yazaki global network',
+            'timeline': '6-12 hours',
+            'cost': 'Very High (+40% logistics cost)',
             'effectiveness': '75%',
             'capacity': f'+{impact_amount * 0.75:.0f} units/day',
-            'risks': ['Inter-plant stock availability', 'Transportation delays'],
-            'prerequisites': ['Stock verification', 'Transport arrangement'],
-            'resource_allocation': 'Warehouse team: 2 FTE for coordination'
-        },
-        {
-            'strategy': 'Overtime Production Acceleration',
-            'description': f'Implement 16-hour shifts to accelerate {material} production',
-            'timeline': '4-6 hours',
-            'cost': 'High (+35% labor cost, ₹80K/day)',
-            'effectiveness': '65%',
-            'capacity': f'+{impact_amount * 0.65:.0f} units/day',
-            'risks': ['Quality control challenges', 'Worker fatigue'],
-            'prerequisites': ['Worker availability', 'Equipment readiness'],
-            'resource_allocation': '24 additional workers across 2 shifts'
         },
         {
-            'strategy': 'Customer Demand Reshuffling',
-            'description': f'Negotiate delivery timeline adjustments with lower priority customers',
-            'timeline': '2-4 hours',
-            'cost': 'Low (relationship management cost only)',
+            'strategy': 'Inventory Reallocation',
+            'description': f'Reallocate {material} from other Yazaki plants',
+            'timeline': '12-24 hours',
+            'cost': 'Medium (+5% handling cost)',
             'effectiveness': '60%',
-            'capacity': f'+{impact_amount * 0.60:.0f} units effective',
-            'risks': ['Customer relationship impact', 'Future order risks'],
-            'prerequisites': ['Customer communication', 'Management approval'],
-            'resource_allocation': 'Account management team: 2 FTE'
+            'capacity': f'+{impact_amount * 0.6:.0f} units/day',
         }
     ]
     
-    # Intelligent strategy recommendation based on multiple factors
-    if impact_amount > 150:
-        recommended = [0, 1, 3]  # Multiple strategies for high impact
-    elif impact_amount > 80:
-        recommended = [0, 2]  # Primary alternate + reallocation
-    elif impact_amount > 40:
-        recommended = [2, 3]  # Reallocation + overtime
+    if impact_amount > 100:
+        recommended = [0, 1]
+    elif impact_amount > 50:
+        recommended = [0, 2]
     else:
-        recommended = [4, 2]  # Demand management + reallocation
+        recommended = [2]
     
     return base_strategies, recommended
 
-# COMPLETE buffer optimization with advanced algorithms
-def calculate_optimal_buffers(df_demand, df_ecosystem):
-    """Calculate optimal safety stock using advanced statistical methods"""
-    buffer_recommendations = {}
-    
-    for material in df_demand['Material'].unique():
-        material_data = df_demand[df_demand['Material'] == material]
-        
-        # Statistical analysis
-        avg_demand = material_data['Demand_Used'].mean()
-        demand_std = material_data['Demand_Used'].std()
-        max_demand = material_data['Demand_Used'].max()
-        demand_cv = demand_std / avg_demand if avg_demand > 0 else 0
-        
-        # Supply variability analysis
-        supply_std = material_data['Supply_Projected'].std()
-        supply_reliability = (material_data['Supply_Projected'] >= material_data['Demand_Used']).mean()
-        
-        # Risk-based buffer calculation
-        service_level = 0.95  # Target 95% service level
-        safety_factor = 1.65   # Z-score for 95% service level
-        
-        # Base safety stock (demand variability)
-        demand_buffer = safety_factor * demand_std
-        
-        # Supply risk buffer
-        supply_risk_multiplier = 1 + (1 - supply_reliability)
-        supply_buffer = demand_buffer * supply_risk_multiplier
-        
-        # Lead time buffer (considering ecosystem disruptions)
-        ecosystem_data = df_ecosystem[df_ecosystem['Material'] == material]
-        avg_lead_time = ecosystem_data['Lead_Time_Days'].mean() if not ecosystem_data.empty else 2
-        disruption_frequency = ecosystem_data['Is_Disrupted'].mean() if not ecosystem_data.empty else 0.1
-        
-        lead_time_buffer = avg_demand * avg_lead_time * (1 + disruption_frequency)
-        
-        # Advanced buffer calculation
-        base_buffer = max(demand_buffer, supply_buffer)
-        total_recommended_buffer = base_buffer + (lead_time_buffer * 0.3)
-        
-        # Current buffer estimation (assume 10% of average demand)
-        current_buffer = avg_demand * 0.10
-        
-        # Cost-benefit analysis
-        unit_holding_cost = 50 + (hash(material) % 100)  # Simulated holding cost
-        shortage_cost = 300 + (hash(material) % 200)     # Simulated shortage cost
-        
-        buffer_gap = total_recommended_buffer - current_buffer
-        holding_cost_increase = buffer_gap * unit_holding_cost
-        risk_reduction = min(95, buffer_gap / avg_demand * 100)
-        
-        buffer_recommendations[material] = {
-            'current_buffer': int(current_buffer),
-            'recommended_buffer': int(total_recommended_buffer),
-            'buffer_gap': int(buffer_gap),
-            'avg_demand': round(avg_demand, 1),
-            'demand_variability': round(demand_cv, 2),
-            'supply_reliability': round(supply_reliability * 100, 1),
-            'service_level_target': 95,
-            'holding_cost_increase': int(holding_cost_increase),
-            'risk_reduction_percent': round(risk_reduction, 1),
-            'roi_months': round(shortage_cost / (holding_cost_increase / 12), 1) if holding_cost_increase > 0 else 0,
-            'priority': 'High' if buffer_gap > avg_demand * 0.2 else 'Medium' if buffer_gap > avg_demand * 0.1 else 'Low'
-        }
-    
-    return buffer_recommendations
-
-# Load comprehensive data
+# Load data
 df_demand = generate_8week_demand_data()
 df_ecosystem = generate_ecosystem_data()
 external_signals = get_external_signals()
 suppliers = get_tier2_suppliers()
 
-# COMPLETE main header with advanced styling
-st.markdown("""
-<div class="main-header">
-    <h1>🔌 Yazaki India Ltd - Advanced Supply Chain Command Center</h1>
-    <p style="font-size: 1.2em; margin-top: 10px;">
-        <strong>AI-Powered Supply Chain Intelligence | 8-Week Demand Planning | Real-time Risk Monitoring</strong>
-    </p>
-    <p style="font-size: 1em; margin-top: 5px; opacity: 0.9;">
-        Electrical Components & Wire Harness Manufacturing | Comprehensive Ecosystem Analysis
-    </p>
-</div>
-""", unsafe_allow_html=True)
-
-# Enhanced sidebar navigation
-st.sidebar.markdown("""
-<div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 1rem; border-radius: 10px; margin-bottom: 1rem;">
-    <h2 style="color: white; margin: 0; text-align: center;">🎯 Command Center</h2>
-</div>
-""", unsafe_allow_html=True)
+# MAIN TITLE (same style as original)
+st.title("Yazaki India Ltd - Supply Chain Command Center")
 
+# Tab Navigation (EXACTLY same as original)
+st.sidebar.title("🎯 Dashboard Navigation")
 dashboard_tab = st.sidebar.radio(
-    "Select Dashboard Module:",
-    [
-        "📊 Advanced Demand & Supply Forecast", 
-        "🌐 Ecosystem Risk & Impact Analysis", 
-        "🛡️ Intelligent Buffer Optimization",
-        "⚡ Real-time Alert Management",
-        "📈 Performance Analytics Dashboard"
-    ],
+    "Select Dashboard:",
+    ["📊 Demand & Supply Forecast", "🌐 Ecosystem Supplier Impact", "🛡️ Buffer Optimizer"],
     index=0
 )
 
-# TAB 1: ADVANCED DEMAND & SUPPLY FORECAST
-if dashboard_tab == "📊 Advanced Demand & Supply Forecast":
+# TAB 1: DEMAND & SUPPLY FORECAST (same structure as original)
+if dashboard_tab == "📊 Demand & Supply Forecast":
     st.markdown("""
     <div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 20px; border-radius: 15px; margin-bottom: 20px;">
         <h2 style="color: white; margin: 0; text-align: center;">
-            📊 8-Week Advanced Planning Horizon
+            🔌 8-Week Planning Horizon | Firm Demand (Days 1-14) | AI-Corrected Demand (Days 15-56)
         </h2>
-        <p style="color: white; text-align: center; margin: 10px 0 0 0;">
-            Firm Orders (Days 1-14) | AI-Enhanced Forecasts (Days 15-56) | Multi-Signal Intelligence Integration
-        </p>
     </div>
     """, unsafe_allow_html=True)
     
-    # Enhanced control panel
-    col1, col2, col3 = st.columns([2, 1, 1])
-    
-    with col1:
-        selected_material = st.selectbox(
-            "🔍 Select Material for Deep Analysis:",
-            df_demand['Material'].unique(),
-            key="forecast_material",
-            format_func=lambda x: f"{x.split('-')[0]} - {x.split('-')[1]}"
-        )
-    
-    with col2:
-        view_mode = st.selectbox(
-            "📈 View Mode:",
-            ["Demand vs Supply", "Risk Analysis", "Fill Rate Analysis"],
-            key="view_mode"
-        )
-    
-    with col3:
-        time_filter = st.selectbox(
-            "⏰ Time Filter:",
-            ["All 8 Weeks", "Firm Period (1-2 weeks)", "Forecast Period (3-8 weeks)"],
-            key="time_filter"
-        )
+    # Material selection
+    selected_material = st.selectbox(
+        "Select Material for Analysis:",
+        df_demand['Material'].unique(),
+        key="forecast_material"
+    )
     
-    # Filter data based on selections
+    # Filter data
     material_df = df_demand[df_demand['Material'] == selected_material].copy()
     
-    if time_filter == "Firm Period (1-2 weeks)":
-        material_df = material_df[material_df['Day'] <= 14]
-    elif time_filter == "Forecast Period (3-8 weeks)":
-        material_df = material_df[material_df['Day'] > 14]
+    # Create visualization (same structure as original)
+    fig = go.Figure()
     
-    # Create comprehensive visualization
-    if view_mode == "Demand vs Supply":
-        fig = go.Figure()
-        
-        # Firm demand
-        firm_data = material_df[material_df['Demand_Type'] == 'Firm']
-        if not firm_data.empty:
-            fig.add_trace(go.Scatter(
-                x=firm_data['Date'],
-                y=firm_data['Demand_Used'],
-                mode='lines+markers',
-                name='Firm Demand (Confirmed Orders)',
-                line=dict(color='#1f77b4', width=4),
-                marker=dict(size=10, symbol='circle'),
-                hovertemplate='<b>Firm Demand</b><br>Date: %{x}<br>Units: %{y}<extra></extra>'
-            ))
-        
-        # AI-corrected demand
-        corrected_data = material_df[material_df['Demand_Type'] == 'AI-Corrected']
-        if not corrected_data.empty:
-            fig.add_trace(go.Scatter(
-                x=corrected_data['Date'],
-                y=corrected_data['Customer_Demand'],
-                mode='lines',
-                name='Customer Forecast',
-                line=dict(color='#ff7f0e', width=2, dash='dot'),
-                opacity=0.7,
-                hovertemplate='<b>Customer Forecast</b><br>Date: %{x}<br>Units: %{y}<extra></extra>'
-            ))
-            
-            fig.add_trace(go.Scatter(
-                x=corrected_data['Date'],
-                y=corrected_data['Corrected_Demand'],
-                mode='lines+markers',
-                name='AI-Corrected Demand (Market Intelligence)',
-                line=dict(color='#d62728', width=3, dash='solid'),
-                marker=dict(size=8, symbol='diamond'),
-                hovertemplate='<b>AI-Corrected Demand</b><br>Date: %{x}<br>Units: %{y}<extra></extra>'
-            ))
-        
-        # Supply projection
-        fig.add_trace(go.Scatter(
-            x=material_df['Date'],
-            y=material_df['Supply_Projected'],
-            mode='lines+markers',
-            name='Supply Projection (with disruptions)',
-            line=dict(color='#2ca02c', width=3),
-            marker=dict(size=6),
-            hovertemplate='<b>Supply Projection</b><br>Date: %{x}<br>Units: %{y}<extra></extra>'
-        ))
-        
-        # Highlight critical shortage areas
-        shortage_data = material_df[material_df['Shortfall'] > 10]
-        if not shortage_data.empty:
-            fig.add_trace(go.Scatter(
-                x=shortage_data['Date'],
-                y=shortage_data['Demand_Used'],
-                mode='markers',
-                name='Critical Shortage Alert',
-                marker=dict(color='red', size=15, symbol='triangle-up'),
-                hovertemplate='<b>SHORTAGE ALERT</b><br>Date: %{x}<br>Demand: %{y}<br>Shortage: ' + 
-                              shortage_data['Shortfall'].astype(str) + '<extra></extra>'
-            ))
+    # Add firm demand (days 1-14)
+    firm_data = material_df[material_df['Demand_Type'] == 'Firm']
+    fig.add_trace(go.Scatter(
+        x=firm_data['Date'],
+        y=firm_data['Demand_Used'],
+        mode='lines+markers',
+        name='Firm Demand (Days 1-14)',
+        line=dict(color='#2E86AB', width=3),
+        marker=dict(size=8)
+    ))
     
-    elif view_mode == "Risk Analysis":
-        fig = go.Figure()
-        
-        # Risk score over time
-        fig.add_trace(go.Scatter(
-            x=material_df['Date'],
-            y=material_df['Risk_Score'],
-            mode='lines+markers',
-            name='Risk Score',
-            line=dict(color='#ff4444', width=3),
-            marker=dict(size=8),
-            yaxis='y',
-            hovertemplate='<b>Risk Score</b><br>Date: %{x}<br>Score: %{y}<extra></extra>'
-        ))
-        
-        # Fill rate
-        fig.add_trace(go.Scatter(
-            x=material_df['Date'],
-            y=material_df['Fill_Rate'],
-            mode='lines+markers',
-            name='Fill Rate (%)',
-            line=dict(color='#2ca02c', width=2),
-            marker=dict(size=6),
-            yaxis='y2',
-            hovertemplate='<b>Fill Rate</b><br>Date: %{x}<br>Rate: %{y}%<extra></extra>'
-        ))
-        
-        # Add risk level zones
-        fig.add_hline(y=50, line_dash="dash", line_color="red", 
-                      annotation_text="Critical Risk Threshold")
-        fig.add_hline(y=30, line_dash="dash", line_color="orange", 
-                      annotation_text="High Risk Threshold")
-        
-        fig.update_layout(
-            yaxis=dict(title="Risk Score", side="left"),
-            yaxis2=dict(title="Fill Rate (%)", side="right", overlaying="y")
-        )
+    # Add AI-corrected demand (days 15-56)
+    corrected_data = material_df[material_df['Demand_Type'] == 'AI-Corrected']
+    fig.add_trace(go.Scatter(
+        x=corrected_data['Date'],
+        y=corrected_data['Demand_Used'],
+        mode='lines+markers',
+        name='AI-Corrected Demand (Days 15-56)',
+        line=dict(color='#A23B72', width=3, dash='dot'),
+        marker=dict(size=6)
+    ))
     
-    elif view_mode == "Fill Rate Analysis":
-        fig = go.Figure()
-        
+    # Add supply projection
+    fig.add_trace(go.Scatter(
+        x=material_df['Date'],
+        y=material_df['Supply_Projected'],
+        mode='lines+markers',
+        name='Supply Projection',
+        line=dict(color='#F18F01', width=2),
+        marker=dict(size=6)
+    ))
+    
+    # Highlight shortage areas
+    shortage_data = material_df[material_df['Shortfall'] > 0]
+    if not shortage_data.empty:
         fig.add_trace(go.Scatter(
-            x=material_df['Date'],
-            y=material_df['Fill_Rate'],
-            mode='lines+markers',
-            name='Fill Rate (%)',
-            line=dict(color='#2ca02c', width=3),
-            marker=dict(size=8),
-            fill='tonexty',
-            hovertemplate='<b>Fill Rate</b><br>Date: %{x}<br>Rate: %{y}%<extra></extra>'
+            x=shortage_data['Date'],
+            y=shortage_data['Shortfall'],
+            mode='markers',
+            name='Shortage Alert',
+            marker=dict(color='red', size=10, symbol='triangle-up'),
+            yaxis='y2'
         ))
-        
-        # Add SLA threshold
-        fig.add_hline(y=95, line_dash="dash", line_color="blue", 
-                      annotation_text="SLA Target (95%)")
-        
-        # Color zones
-        fig.add_hrect(y0=95, y1=100, fillcolor="green", opacity=0.1, annotation_text="Excellent")
-        fig.add_hrect(y0=85, y1=95, fillcolor="yellow", opacity=0.1, annotation_text="Acceptable")
-        fig.add_hrect(y0=0, y1=85, fillcolor="red", opacity=0.1, annotation_text="Critical")
     
     fig.update_layout(
-        title=f"Advanced Analysis: {selected_material} ({view_mode})",
+        title=f"8-Week Demand & Supply Forecast - {selected_material}",
         xaxis_title="Date",
-        yaxis_title="Units" if view_mode == "Demand vs Supply" else ("Risk Score" if view_mode == "Risk Analysis" else "Fill Rate (%)"),
+        yaxis_title="Units",
+        yaxis2=dict(title="Shortage", overlaying='y', side='right'),
         height=600,
         showlegend=True,
-        hovermode='x unified',
-        template='plotly_white'
+        hovermode='x unified'
     )
     
     st.plotly_chart(fig, use_container_width=True)
     
-    # Advanced metrics dashboard
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        avg_fill_rate = material_df['Fill_Rate'].mean()
-        st.metric(
-            "Average Fill Rate",
-            f"{avg_fill_rate:.1f}%",
-            delta=f"{avg_fill_rate - 95:.1f}% vs Target",
-            delta_color="inverse"
-        )
-    
-    with col2:
-        total_shortage = material_df['Shortfall'].sum()
-        st.metric(
-            "Total Shortage Risk",
-            f"{total_shortage} units",
-            delta=f"{material_df[material_df['Shortfall'] > 0].shape[0]} days affected"
-        )
-    
-    with col3:
-        avg_risk = material_df['Risk_Score'].mean()
-        risk_trend = "↗" if material_df['Risk_Score'].iloc[-1] > material_df['Risk_Score'].iloc[0] else "↘"
-        st.metric(
-            "Average Risk Score",
-            f"{avg_risk:.1f}",
-            delta=f"{risk_trend} Trending"
-        )
+    # Generate and display alerts (same structure as original)
+    alerts = generate_detailed_alerts(df_demand)
     
-    with col4:
-        demand_variability = material_df['Demand_Used'].std() / material_df['Demand_Used'].mean()
-        st.metric(
-            "Demand Variability",
-            f"{demand_variability:.2f} CV",
-            delta="Higher = More Volatile"
-        )
+    if alerts:
+        st.markdown("""
+        <div style="background: #ffe6e6; padding: 15px; border-radius: 10px; border-left: 5px solid #ff4444; margin: 20px 0;">
+            <h3 style="color: #cc0000; margin-top: 0;">⚠️ Critical Supply Chain Alerts</h3>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        for alert in alerts[:3]:  # Show top 3 alerts
+            severity_color = {'Critical': '#ff4444', 'High': '#ff8800', 'Medium': '#ffcc00'}[alert['severity']]
+            
+            st.markdown(f"""
+            <div style="background: white; padding: 15px; border-radius: 10px; border-left: 5px solid {severity_color}; margin: 10px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                <h4 style="color: {severity_color}; margin: 0 0 10px 0;">
+                    🚨 {alert['severity']} Alert: {alert['material']}
+                </h4>
+                <p style="margin: 5px 0;">
+                    <strong>Date:</strong> {alert['date']} ({alert['week']}) | 
+                    <strong>Shortage:</strong> {alert['shortage']} units | 
+                    <strong>Type:</strong> {alert['demand_type']}
+                </p>
+                <p style="margin: 5px 0;"><strong>Root Causes:</strong></p>
+                <ul style="margin: 5px 0;">
+                    {''.join([f"<li>{cause}</li>" for cause in alert['root_causes']])}
+                </ul>
+                <p style="margin: 10px 0 5px 0;"><strong>🎯 Recommended Action:</strong></p>
+                <div style="background: #f0f8ff; padding: 10px; border-radius: 5px;">
+                    <strong>{alert['best_option']['option']}</strong><br>
+                    Impact: {alert['best_option']['impact']} | Cost: {alert['best_option']['cost']} | Timeline: {alert['best_option']['timeline']}
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
 
-elif dashboard_tab == "🌐 Ecosystem Risk & Impact Analysis":
+# TAB 2: ECOSYSTEM SUPPLIER IMPACT (same structure as original)
+elif dashboard_tab == "🌐 Ecosystem Supplier Impact":
     st.markdown("""
     <div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 20px; border-radius: 15px; margin-bottom: 20px;">
         <h2 style="color: white; margin: 0; text-align: center;">
-            🌐 Comprehensive Ecosystem Impact Analysis
+            🌐 Tier 2 Supplier Disruption Analysis | Cascading Impact Modeling | Automated Mitigation Response
         </h2>
-        <p style="color: white; text-align: center; margin: 10px 0 0 0;">
-            Tier-2 Supplier Intelligence | Cascading Risk Modeling | Automated Response Systems
-        </p>
     </div>
     """, unsafe_allow_html=True)
     
-    # Supplier selection with enhanced information
-    supplier_names = list(suppliers.keys())
+    # Supplier selection
     selected_supplier = st.selectbox(
-        "🏭 Select Tier-2 Supplier for Deep Dive Analysis:",
-        supplier_names,
-        key="ecosystem_supplier",
-        format_func=lambda x: f"{x} ({suppliers[x]['location']} - {suppliers[x]['performance_rating']}⭐)"
+        "Select Tier-2 Supplier for Analysis:",
+        df_ecosystem['Supplier'].unique(),
+        key="ecosystem_supplier"
     )
     
-    # Supplier profile card
-    supplier_info = suppliers[selected_supplier]
-    
-    st.markdown(f"""
-    <div class="supplier-card">
-        <h3>🏭 {selected_supplier}</h3>
-        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-top: 15px;">
-            <div><strong>📍 Location:</strong> {supplier_info['location']}</div>
-            <div><strong>⚡ Capacity:</strong> {supplier_info['capacity']} units/day</div>
-            <div><strong>🎯 Reliability:</strong> {supplier_info['reliability']}%</div>
-            <div><strong>⏱️ Lead Time:</strong> {supplier_info['lead_time']} days</div>
-            <div><strong>⭐ Performance:</strong> {supplier_info['performance_rating']}/5.0</div>
-            <div><strong>💼 Financial Health:</strong> {supplier_info['financial_health']}</div>
-        </div>
-        <div style="margin-top: 10px;">
-            <strong>🎯 Materials Supplied:</strong>
-            <ul style="margin: 5px 0;">
-                {''.join([f"<li>{material}</li>" for material in supplier_info['materials']])}
-            </ul>
-        </div>
-        <div style="margin-top: 10px;">
-            <strong>⚠️ Key Risk Factors:</strong>
-            <ul style="margin: 5px 0;">
-                {''.join([f"<li>{risk}</li>" for risk in supplier_info['risk_factors']])}
-            </ul>
-        </div>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Filter ecosystem data
+    # Filter and analyze
     supplier_df = df_ecosystem[df_ecosystem['Supplier'] == selected_supplier]
     
-    # Advanced visualization
-    tab1, tab2, tab3 = st.tabs(["📊 Impact Analysis", "📈 Financial Impact", "🔄 Recovery Timeline"])
+    col1, col2 = st.columns(2)
     
-    with tab1:
-        col1, col2 = st.columns(2)
+    with col1:
+        # Supplier disruption chart
+        fig1 = go.Figure()
         
-        with col1:
-            # Tier-2 supplier disruption chart
-            fig1 = go.Figure()
+        for material in supplier_df['Material'].unique():
+            material_data = supplier_df[supplier_df['Material'] == material]
             
-            for material in supplier_df['Material'].unique():
-                material_data = supplier_df[supplier_df['Material'] == material]
-                
-                fig1.add_trace(go.Scatter(
-                    x=material_data['Date'],
-                    y=material_data['Tier2_Normal_Supply'],
-                    mode='lines',
-                    name=f'{material.split("-")[1]} - Normal',
-                    line=dict(width=3),
-                    opacity=0.8
-                ))
-                
-                fig1.add_trace(go.Scatter(
-                    x=material_data['Date'],
-                    y=material_data['Tier2_Disrupted_Supply'],
-                    mode='lines+markers',
-                    name=f'{material.split("-")[1]} - Disrupted',
-                    line=dict(dash='dot', width=3),
-                    marker=dict(size=6)
-                ))
-            
-            fig1.update_layout(
-                title=f"Tier-2 Supply Impact: {selected_supplier.split()[0]}...",
-                xaxis_title="Date",
-                yaxis_title="Supply Units/Day",
-                height=400,
-                template='plotly_white'
-            )
+            fig1.add_trace(go.Scatter(
+                x=material_data['Date'],
+                y=material_data['Tier2_Normal_Supply'],
+                mode='lines',
+                name=f'{material} - Normal',
+                line=dict(width=2)
+            ))
             
-            st.plotly_chart(fig1, use_container_width=True)
+            fig1.add_trace(go.Scatter(
+                x=material_data['Date'],
+                y=material_data['Tier2_Disrupted_Supply'],
+                mode='lines',
+                name=f'{material} - Disrupted',
+                line=dict(dash='dot', width=2)
+            ))
         
-        with col2:
-            # Yazaki cascading impact chart
-            fig2 = go.Figure()
-            
-            for material in supplier_df['Material'].unique():
-                material_data = supplier_df[supplier_df['Material'] == material]
-                
-                fig2.add_trace(go.Scatter(
-                    x=material_data['Date'],
-                    y=material_data['Yazaki_Normal_Supply'],
-                    mode='lines',
-                    name=f'{material.split("-")[1]} - Normal',
-                    line=dict(width=3),
-                    opacity=0.8
-                ))
-                
-                fig2.add_trace(go.Scatter(
-                    x=material_data['Date'],
-                    y=material_data['Yazaki_Impacted_Supply'],
-                    mode='lines+markers',
-                    name=f'{material.split("-")[1]} - Impacted',
-                    line=dict(dash='solid', width=3),
-                    marker=dict(size=8, symbol='triangle-down')
-                ))
-            
-            fig2.update_layout(
-                title="Cascading Impact on Yazaki Production",
-                xaxis_title="Date",
-                yaxis_title="Available Supply Units/Day",
-                height=400,
-                template='plotly_white'
-            )
-            
-            st.plotly_chart(fig2, use_container_width=True)
+        fig1.update_layout(
+            title=f"Tier-2 Supplier Impact: {selected_supplier}",
+            xaxis_title="Date",
+            yaxis_title="Supply Units",
+            height=400
+        )
+        
+        st.plotly_chart(fig1, use_container_width=True)
     
-    with tab2:
-        # Financial impact analysis
-        total_financial_impact = supplier_df['Financial_Impact_INR'].sum()
+    with col2:
+        # Yazaki impact chart
+        fig2 = go.Figure()
         
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            st.metric("Total Financial Impact", f"₹{total_financial_impact:,}", delta="14-day period")
-        with col2:
-            peak_impact = supplier_df['Financial_Impact_INR'].max()
-            st.metric("Peak Daily Impact", f"₹{peak_impact:,}", delta="Maximum single day")
-        with col3:
-            avg_impact = supplier_df[supplier_df['Financial_Impact_INR'] > 0]['Financial_Impact_INR'].mean()
-            st.metric("Average Daily Impact", f"₹{avg_impact:,.0f}", delta="When disrupted")
+        for material in supplier_df['Material'].unique():
+            material_data = supplier_df[supplier_df['Material'] == material]
+            
+            fig2.add_trace(go.Scatter(
+                x=material_data['Date'],
+                y=material_data['Yazaki_Normal_Supply'],
+                mode='lines',
+                name=f'{material} - Normal',
+                line=dict(width=2)
+            ))
+            
+            fig2.add_trace(go.Scatter(
+                x=material_data['Date'],
+                y=material_data['Yazaki_Impacted_Supply'],
+                mode='lines',
+                name=f'{material} - Impacted',
+                line=dict(dash='dot', width=2)
+            ))
         
-        # Financial impact chart
-        fig3 = px.bar(
-            supplier_df,
-            x='Date',
-            y='Financial_Impact_INR',
-            color='Material',
-            title=f"Daily Financial Impact from {selected_supplier} Disruptions",
-            labels={'Financial_Impact_INR': 'Financial Impact (₹)'}
+        fig2.update_layout(
+            title=f"Cascading Impact on Yazaki Production",
+            xaxis_title="Date",
+            yaxis_title="Supply Units",
+            height=400
         )
-        fig3.update_layout(height=400, template='plotly_white')
-        st.plotly_chart(fig3, use_container_width=True)
-    
-    with tab3:
-        # Recovery timeline analysis
-        disrupted_days = supplier_df[supplier_df['Is_Disrupted'] == True]
         
-        if not disrupted_days.empty:
-            st.markdown("### 🔄 Recovery Timeline Analysis")
-            
-            for _, day_data in disrupted_days.head(3).iterrows():  # Show first 3 disruptions
+        st.plotly_chart(fig2, use_container_width=True)
+    
+    # Disruption alerts (same structure as original)
+    disrupted_days = supplier_df[supplier_df['Is_Disrupted'] == True]
+    
+    if not disrupted_days.empty:
+        for _, alert_day in disrupted_days.iterrows():
+            if alert_day['Tier2_Impact'] > 0:
+                strategies, recommended = generate_mitigation_strategies(
+                    alert_day['Supplier'],
+                    alert_day['Material'],
+                    alert_day['Tier2_Impact'],
+                    1
+                )
+                
                 st.markdown(f"""
-                <div class="alert-high">
-                    <h4>📅 {day_data['Date'].strftime('%Y-%m-%d')} - {day_data['Material']}</h4>
-                    <p><strong>Disruption:</strong> {day_data['Disruption_Cause']}</p>
-                    <p><strong>Severity:</strong> {day_data['Disruption_Severity']}</p>
-                    <p><strong>Impact:</strong> -{day_data['Tier2_Impact']} units → Yazaki impact: -{day_data['Yazaki_Impact']} units (after {day_data['Lead_Time_Days']} days)</p>
-                    <p><strong>Recovery Time:</strong> {day_data['Recovery_Timeline_Days']} days</p>
+                <div style="background: white; padding: 15px; border-radius: 10px; border-left: 5px solid #ff8800; margin: 10px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                    <h4 style="color: #ff8800; margin: 0 0 10px 0;">
+                        🏭 Supplier Disruption Alert
+                    </h4>
+                    <p style="margin: 5px 0;">
+                        <strong>Supplier:</strong> {alert_day['Supplier']} | 
+                        <strong>Material:</strong> {alert_day['Material']}
+                    </p>
+                    <p style="margin: 5px 0;">
+                        <strong>Root Cause:</strong> {alert_day['Disruption_Cause']}
+                    </p>
+                    <p style="margin: 5px 0;">
+                        <strong>Impact:</strong> -{alert_day['Tier2_Impact']} units | 
+                        <strong>Yazaki Impact:</strong> -{alert_day['Yazaki_Impact']} units (after {alert_day['Lead_Time_Days']} days)
+                    </p>
                 </div>
                 """, unsafe_allow_html=True)
+                
+                break  # Show only first alert to avoid repetition
 
-elif dashboard_tab == "🛡️ Intelligent Buffer Optimization":
+# TAB 3: BUFFER OPTIMIZER (same structure as original)
+elif dashboard_tab == "🛡️ Buffer Optimizer":
     st.markdown("""
     <div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 20px; border-radius: 15px; margin-bottom: 20px;">
         <h2 style="color: white; margin: 0; text-align: center;">
-            🛡️ AI-Driven Intelligent Buffer Optimization
+            🛡️ AI-driven safety-stock recommendations across the full network
         </h2>
-        <p style="color: white; text-align: center; margin: 10px 0 0 0;">
-            Statistical Analysis | Risk-Based Safety Stock | Cost-Benefit Optimization
-        </p>
     </div>
     """, unsafe_allow_html=True)
     
-    # Calculate optimal buffers
-    buffer_recommendations = calculate_optimal_buffers(df_demand, df_ecosystem)
-    
-    # Overview metrics
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        total_current = sum([rec['current_buffer'] for rec in buffer_recommendations.values()])
-        st.metric("Current Total Buffer", f"{total_current:,} units")
-    
-    with col2:
-        total_recommended = sum([rec['recommended_buffer'] for rec in buffer_recommendations.values()])
-        st.metric("Recommended Total", f"{total_recommended:,} units")
-    
-    with col3:
-        total_gap = sum([rec['buffer_gap'] for rec in buffer_recommendations.values()])
-        st.metric("Total Buffer Gap", f"{total_gap:,} units", delta=f"+{((total_gap/total_current)*100):.1f}%")
+    # Buffer optimization logic (same as original)
+    buffer_data = []
+    for material in df_demand['Material'].unique():
+        material_data = df_demand[df_demand['Material'] == material]
+        avg_demand = material_data['Demand_Used'].mean()
+        demand_volatility = material_data['Demand_Used'].std()
+        max_shortfall = material_data['Shortfall'].max()
+        
+        # Calculate recommended buffer
+        base_buffer = avg_demand * 0.15  # 15% base buffer
+        volatility_buffer = demand_volatility * 1.5
+        risk_buffer = max_shortfall * 0.8
+        
+        recommended_buffer = int(base_buffer + volatility_buffer + risk_buffer)
+        current_buffer = int(avg_demand * 0.10)  # Assume current is 10%
+        
+        buffer_data.append({
+            'Material': material,
+            'Current_Buffer': current_buffer,
+            'Recommended_Buffer': recommended_buffer,
+            'Gap': recommended_buffer - current_buffer,
+            'Cost_Impact': f"₹{(recommended_buffer - current_buffer) * 150:,}",  # Assuming ₹150 per unit
+            'Risk_Reduction': f"{min(90, max_shortfall * 2):.0f}%"
+        })
     
-    with col4:
-        total_cost = sum([rec['holding_cost_increase'] for rec in buffer_recommendations.values()])
-        st.metric("Investment Required", f"₹{total_cost:,}")
+    buffer_df = pd.DataFrame(buffer_data)
     
-    # Buffer analysis visualization
-    materials = list(buffer_recommendations.keys())
-    current_buffers = [buffer_recommendations[mat]['current_buffer'] for mat in materials]
-    recommended_buffers = [buffer_recommendations[mat]['recommended_buffer'] for mat in materials]
+    # Display buffer recommendations
+    st.subheader("📊 Safety Stock Recommendations")
     
     fig = go.Figure()
     
     fig.add_trace(go.Bar(
-        name='Current Safety Stock',
-        x=[mat.split('-')[1] for mat in materials],
-        y=current_buffers,
-        marker_color='lightblue',
-        text=current_buffers,
-        textposition='auto'
+        name='Current Buffer',
+        x=buffer_df['Material'],
+        y=buffer_df['Current_Buffer'],
+        marker_color='lightblue'
     ))
     
     fig.add_trace(go.Bar(
-        name='Recommended Safety Stock',
-        x=[mat.split('-')[1] for mat in materials],
-        y=recommended_buffers,
-        marker_color='orange',
-        text=recommended_buffers,
-        textposition='auto'
+        name='Recommended Buffer',
+        x=buffer_df['Material'],
+        y=buffer_df['Recommended_Buffer'],
+        marker_color='orange'
     ))
     
     fig.update_layout(
-        title="Current vs Optimal Safety Stock Levels by Material",
+        title="Current vs Recommended Safety Stock Levels",
         xaxis_title="Materials",
-        yaxis_title="Safety Stock Units",
+        yaxis_title="Buffer Stock Units",
         barmode='group',
-        height=500,
-        template='plotly_white'
+        height=400
     )
     
     st.plotly_chart(fig, use_container_width=True)
     
-    # Detailed recommendations table
-    st.subheader("📋 Detailed Buffer Optimization Recommendations")
-    
-    buffer_df_display = pd.DataFrame([
-        {
-            'Material': mat.split('-')[1],
-            'Current Buffer': rec['current_buffer'],
-            'Recommended Buffer': rec['recommended_buffer'],
-            'Gap (Units)': rec['buffer_gap'],
-            'Investment (₹)': f"₹{rec['holding_cost_increase']:,}",
-            'Risk Reduction': f"{rec['risk_reduction_percent']}%",
-            'ROI (Months)': rec['roi_months'],
-            'Priority': rec['priority'],
-            'Demand Variability': rec['demand_variability'],
-            'Supply Reliability': f"{rec['supply_reliability']}%"
-        }
-        for mat, rec in buffer_recommendations.items()
-    ])
-    
-    # Color-code priority
-    def color_priority(val):
-        if val == 'High':
-            return 'background-color: #ffebee'
-        elif val == 'Medium':
-            return 'background-color: #fff3e0'
-        else:
-            return 'background-color: #e8f5e8'
-    
-    styled_df = buffer_df_display.style.applymap(
-        color_priority, subset=['Priority']
-    ).format({
-        'Demand Variability': '{:.2f}',
-        'ROI (Months)': '{:.1f}'
-    })
-    
-    st.dataframe(styled_df, use_container_width=True, height=400)
-
-elif dashboard_tab == "⚡ Real-time Alert Management":
-    st.markdown("""
-    <div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 20px; border-radius: 15px; margin-bottom: 20px;">
-        <h2 style="color: white; margin: 0; text-align: center;">
-            ⚡ Real-time Supply Chain Alert Management System
-        </h2>
-        <p style="color: white; text-align: center; margin: 10px 0 0 0;">
-            Advanced Alert Generation | Intelligent Prioritization | Automated Response Recommendations
-        </p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Generate comprehensive alerts
-    alerts = generate_detailed_alerts(df_demand)
-    
-    # Alert summary dashboard
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        critical_alerts = len([a for a in alerts if a['severity'] == 'Critical'])
-        st.metric("Critical Alerts", critical_alerts, delta="Immediate Action Required")
-    
-    with col2:
-        high_alerts = len([a for a in alerts if a['severity'] == 'High'])
-        st.metric("High Priority", high_alerts, delta="24hr Response Time")
-    
-    with col3:
-        total_revenue_risk = sum([a['revenue_at_risk'] for a in alerts])
-        st.metric("Revenue at Risk", f"₹{total_revenue_risk:,}", delta="8-week period")
-    
-    with col4:
-        avg_shortage = np.mean([a['shortage'] for a in alerts]) if alerts else 0
-        st.metric("Avg Shortage", f"{avg_shortage:.0f} units", delta="Per incident")
-    
-    # Alert filtering
-    col1, col2, col3 = st.columns(3)
-    
-    with col1:
-        severity_filter = st.multiselect(
-            "Filter by Severity:",
-            ["Critical", "High", "Medium", "Low"],
-            default=["Critical", "High"],
-            key="severity_filter"
-        )
-    
-    with col2:
-        material_filter = st.multiselect(
-            "Filter by Material Category:",
-            df_demand['Material_Category'].unique(),
-            key="material_filter"
-        )
-    
-    with col3:
-        show_resolved = st.checkbox("Show Resolved Alerts", key="show_resolved")
-    
-    # Filter alerts
-    filtered_alerts = [
-        alert for alert in alerts
-        if alert['severity'] in severity_filter and
-        (not material_filter or any(cat in alert['material'] for cat in material_filter))
-    ]
-    
-    # Display alerts with advanced formatting
-    st.subheader(f"🚨 Active Alerts ({len(filtered_alerts)} items)")
-    
-    for i, alert in enumerate(filtered_alerts[:10]):  # Show top 10
-        severity_colors = {
-            'Critical': '#ff4444',
-            'High': '#ff8800',
-            'Medium': '#ffcc00',
-            'Low': '#4CAF50'
-        }
-        
-        severity_color = severity_colors.get(alert['severity'], '#gray')
-        
-        with st.expander(
-            f"🚨 {alert['severity']} Alert: {alert['material'].split('-')[1]} | "
-            f"Shortage: {alert['shortage']} units | Revenue Risk: ₹{alert['revenue_at_risk']:,}",
-            expanded=(i < 3)  # Auto-expand first 3 alerts
-        ):
-            col1, col2 = st.columns([2, 1])
-            
-            with col1:
-                st.markdown(f"""
-                <div style="border-left: 5px solid {severity_color}; padding-left: 15px;">
-                    <h4 style="color: {severity_color}; margin: 0;">Alert Details</h4>
-                    <p><strong>Alert ID:</strong> {alert['alert_id']}</p>
-                    <p><strong>Material:</strong> {alert['material']}</p>
-                    <p><strong>Date:</strong> {alert['date']} ({alert['week']})</p>
-                    <p><strong>Demand Type:</strong> {alert['demand_type']}</p>
-                    <p><strong>Fill Rate:</strong> {alert['fill_rate']}%</p>
-                    <p><strong>Risk Score:</strong> {alert['risk_score']}/100</p>
-                    <p><strong>Customer Impact:</strong> {alert['customer_impact']}</p>
-                </div>
-                """, unsafe_allow_html=True)
-                
-                st.markdown("**Root Cause Analysis:**")
-                for cause in alert['root_causes']:
-                    st.markdown(f"• {cause}")
-            
-            with col2:
-                st.markdown("**🎯 Recommended Action**")
-                best_option = alert['best_option']
-                
-                st.markdown(f"""
-                <div class="mitigation-card">
-                    <h5>{best_option['option']}</h5>
-                    <p><strong>Impact:</strong> {best_option['impact']}</p>
-                    <p><strong>Timeline:</strong> {best_option['timeline']}</p>
-                    <p><strong>Cost:</strong> {best_option['cost']}</p>
-                    <p><strong>Success Rate:</strong> {best_option['success_probability']}</p>
-                    <p><strong>Resources:</strong> {best_option['resource_requirements']}</p>
-                </div>
-                """, unsafe_allow_html=True)
-                
-                if st.button(f"Execute Action {i+1}", key=f"execute_{i}"):
-                    st.success(f"✅ Mitigation action initiated: {best_option['option']}")
-                    st.session_state.executed_mitigations.append({
-                        'alert_id': alert['alert_id'],
-                        'action': best_option['option'],
-                        'timestamp': datetime.now()
-                    })
+    # Buffer recommendations table
+    st.subheader("📋 Detailed Buffer Analysis")
+    st.dataframe(buffer_df, use_container_width=True)
 
-elif dashboard_tab == "📈 Performance Analytics Dashboard":
-    st.markdown("""
-    <div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 20px; border-radius: 15px; margin-bottom: 20px;">
-        <h2 style="color: white; margin: 0; text-align: center;">
-            📈 Advanced Performance Analytics Dashboard
-        </h2>
-        <p style="color: white; text-align: center; margin: 10px 0 0 0;">
-            KPI Monitoring | Trend Analysis | Predictive Insights | Supplier Scorecards
-        </p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # KPI Summary Cards
-    col1, col2, col3, col4, col5 = st.columns(5)
-    
-    with col1:
-        overall_fill_rate = df_demand['Fill_Rate'].mean()
-        st.metric(
-            "Overall Fill Rate",
-            f"{overall_fill_rate:.1f}%",
-            delta=f"{overall_fill_rate - 95:.1f}% vs SLA"
-        )
-    
-    with col2:
-        total_demand = df_demand['Demand_Used'].sum()
-        st.metric("Total 8-Week Demand", f"{total_demand:,} units")
-    
-    with col3:
-        supply_efficiency = (df_demand['Supply_Projected'].sum() / df_demand['Supply_Plan'].sum()) * 100
-        st.metric(
-            "Supply Efficiency",
-            f"{supply_efficiency:.1f}%",
-            delta="Actual vs Plan"
-        )
-    
-    with col4:
-        risk_incidents = len(df_demand[df_demand['Risk_Score'] >= 30])
-        st.metric("Risk Incidents", f"{risk_incidents}", delta="High+ Risk Days")
-    
-    with col5:
-        supplier_reliability = df_ecosystem.groupby('Supplier')['Supplier_Reliability'].first().mean()
-        st.metric(
-            "Avg Supplier Reliability",
-            f"{supplier_reliability:.1f}%",
-            delta="Network Average"
-        )
-    
-    # Advanced analytics tabs
-    tab1, tab2, tab3, tab4 = st.tabs(["📊 Trend Analysis", "🎯 Supplier Scorecard", "🔮 Predictive Insights", "💰 Cost Analysis"])
-    
-    with tab1:
-        st.subheader("📈 Weekly Performance Trends")
-        
-        # Weekly aggregation
-        weekly_performance = df_demand.groupby('Week_Number').agg({
-            'Fill_Rate': 'mean',
-            'Risk_Score': 'mean',
-            'Shortfall': 'sum',
-            'Demand_Used': 'sum',
-            'Supply_Projected': 'sum'
-        }).reset_index()
-        
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=('Fill Rate Trend', 'Risk Score Trend', 'Weekly Demand vs Supply', 'Shortage Incidents'),
-            specs=[[{"secondary_y": False}, {"secondary_y": False}],
-                   [{"secondary_y": True}, {"secondary_y": False}]]
-        )
-        
-        # Fill rate trend
-        fig.add_trace(
-            go.Scatter(x=weekly_performance['Week_Number'], y=weekly_performance['Fill_Rate'],
-                      mode='lines+markers', name='Fill Rate', line=dict(color='green', width=3)),
-            row=1, col=1
-        )
-        
-        # Risk score trend
-        fig.add_trace(
-            go.Scatter(x=weekly_performance['Week_Number'], y=weekly_performance['Risk_Score'],
-                      mode='lines+markers', name='Risk Score', line=dict(color='red', width=3)),
-            row=1, col=2
-        )
-        
-        # Demand vs Supply
-        fig.add_trace(
-            go.Bar(x=weekly_performance['Week_Number'], y=weekly_performance['Demand_Used'],
-                  name='Weekly Demand', marker_color='blue', opacity=0.7),
-            row=2, col=1
-        )
-        fig.add_trace(
-            go.Scatter(x=weekly_performance['Week_Number'], y=weekly_performance['Supply_Projected'],
-                      mode='lines+markers', name='Weekly Supply', line=dict(color='orange', width=3)),
-            row=2, col=1, secondary_y=True
-        )
-        
-        # Shortage incidents
-        fig.add_trace(
-            go.Bar(x=weekly_performance['Week_Number'], y=weekly_performance['Shortfall'],
-                  name='Weekly Shortage', marker_color='red', opacity=0.8),
-            row=2, col=2
-        )
-        
-        fig.update_layout(height=600, showlegend=True, template='plotly_white')
-        st.plotly_chart(fig, use_container_width=True)
-    
-    with tab2:
-        st.subheader("🎯 Comprehensive Supplier Scorecard")
-        
-        # Calculate supplier metrics
-        supplier_metrics = []
-        for supplier_name, supplier_info in suppliers.items():
-            supplier_ecosystem = df_ecosystem[df_ecosystem['Supplier'] == supplier_name]
-            
-            if not supplier_ecosystem.empty:
-                reliability_score = (1 - supplier_ecosystem['Is_Disrupted'].mean()) * 100
-                avg_impact = supplier_ecosystem['Yazaki_Impact'].mean()
-                financial_impact = supplier_ecosystem['Financial_Impact_INR'].sum()
-                recovery_time = supplier_ecosystem['Recovery_Timeline_Days'].max()
-                
-                # Overall score calculation (weighted average)
-                overall_score = (
-                    reliability_score * 0.3 +
-                    supplier_info['performance_rating'] * 20 * 0.25 +
-                    (100 - min(avg_impact * 2, 100)) * 0.25 +
-                    (100 - min(recovery_time * 10, 100)) * 0.2
-                )
-                
-                supplier_metrics.append({
-                    'Supplier': supplier_name.split()[0] + '...',  # Shortened name
-                    'Overall Score': round(overall_score, 1),
-                    'Reliability %': round(reliability_score, 1),
-                    'Performance Rating': supplier_info['performance_rating'],
-                    'Avg Impact': round(avg_impact, 0),
-                    'Financial Impact (₹)': f"₹{financial_impact:,}",
-                    'Max Recovery Time': f"{recovery_time} days",
-                    'Location': supplier_info['location'].split(',')[0],  # City only
-                    'Backup Available': '✅' if supplier_info['backup_available'] else '❌'
-                })
-        
-        supplier_scorecard_df = pd.DataFrame(supplier_metrics)
-        
-        # Display scorecard with conditional formatting
-        def score_color(val):
-            if val >= 80:
-                return 'background-color: #d4edda'  # Green
-            elif val >= 60:
-                return 'background-color: #fff3cd'  # Yellow
-            else:
-                return 'background-color: #f8d7da'  # Red
-        
-        styled_scorecard = supplier_scorecard_df.style.applymap(
-            score_color, subset=['Overall Score']
-        ).applymap(
-            score_color, subset=['Reliability %']
-        )
-        
-        st.dataframe(styled_scorecard, use_container_width=True)
-        
-        # Supplier comparison radar chart
-        fig_radar = go.Figure()
-        
-        categories = ['Reliability', 'Performance', 'Recovery Speed', 'Cost Impact', 'Risk Level']
-        
-        for supplier_metric in supplier_metrics:
-            reliability = supplier_metric['Reliability %']
-            performance = supplier_metric['Performance Rating'] * 20
-            recovery = 100 - (int(supplier_metric['Max Recovery Time'].split()[0]) * 10)
-            cost_impact = 100 - min(50, 100)  # Simplified
-            risk_level = 100 - supplier_metric['Avg Impact']
-            
-            values = [reliability, performance, recovery, cost_impact, risk_level]
-            
-            fig_radar.add_trace(go.Scatterpolar(
-                r=values + [values[0]],  # Close the polygon
-                theta=categories + [categories[0]],
-                fill='toself',
-                name=supplier_metric['Supplier'],
-                opacity=0.6
-            ))
-        
-        fig_radar.update_layout(
-            polar=dict(
-                radialaxis=dict(visible=True, range=[0, 100])
-            ),
-            showlegend=True,
-            title="Supplier Performance Radar Comparison",
-            height=500
-        )
-        
-        st.plotly_chart(fig_radar, use_container_width=True)
-    
-    with tab3:
-        st.subheader("🔮 Predictive Insights & Future Projections")
-        
-        # Simple trend predictions (using linear regression concepts)
-        st.markdown("**Key Predictive Insights:**")
-        
-        # Demand trend prediction
-        demand_trend = np.polyfit(range(len(df_demand)), df_demand.groupby('Day')['Demand_Used'].sum().values, 1)
-        demand_direction = "increasing" if demand_trend[0] > 0 else "decreasing"
-        
-        st.markdown(f"""
-        <div class="metric-card">
-            <h4>📈 Demand Trend Forecast</h4>
-            <p>Overall demand is <strong>{demand_direction}</strong> at a rate of <strong>{abs(demand_trend[0]):.1f} units/day</strong></p>
-            <p>Expected total demand for next 4 weeks: <strong>{int(df_demand['Demand_Used'].sum() * 0.5 + demand_trend[0] * 28):,} units</strong></p>
-        </div>
-        """, unsafe_allow_html=True)
-        
-        # Risk prediction
-        high_risk_materials = df_demand.groupby('Material')['Risk_Score'].mean().sort_values(ascending=False).head(3)
-        
-        st.markdown(f"""
-        <div class="metric-card">
-            <h4>⚠️ High-Risk Material Forecast</h4>
-            <p>Top 3 materials with highest predicted risk:</p>
-            <ul>
-                {''.join([f'<li><strong>{mat.split("-")[1]}:</strong> {score:.1f} risk score</li>' for mat, score in high_risk_materials.items()])}
-            </ul>
-        </div>
-        """, unsafe_allow_html=True)
-        
-        # Supplier risk prediction
-        supplier_risk = df_ecosystem.groupby('Supplier').agg({
-            'Is_Disrupted': 'sum',
-            'Yazaki_Impact': 'sum',
-            'Financial_Impact_INR': 'sum'
-        }).sort_values('Financial_Impact_INR', ascending=False)
-        
-        st.markdown("**🏭 Supplier Risk Prediction:**")
-        for supplier in supplier_risk.head(2).index:
-            risk_data = supplier_risk.loc[supplier]
-            st.markdown(f"""
-            <div class="alert-medium">
-                <strong>{supplier.split()[0]}:</strong> 
-                {int(risk_data['Is_Disrupted'])} disruption days, 
-                ₹{int(risk_data['Financial_Impact_INR']):,} total impact
-            </div>
-            """, unsafe_allow_html=True)
-    
-    with tab4:
-        st.subheader("💰 Comprehensive Cost Analysis")
-        
-        # Cost breakdown analysis
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.markdown("**Supply Chain Cost Breakdown:**")
-            
-            # Simulated cost analysis
-            total_material_cost = df_demand['Demand_Used'].sum() * 150  # ₹150 average per unit
-            disruption_cost = df_ecosystem['Financial_Impact_INR'].sum()
-            buffer_cost = sum([rec['holding_cost_increase'] for rec in buffer_recommendations.values()])
-            mitigation_cost = len(alerts) * 50000  # ₹50K average per mitigation
-            
-            cost_data = {
-                'Category': ['Material Costs', 'Disruption Impact', 'Buffer Investment', 'Mitigation Costs'],
-                'Amount (₹)': [total_material_cost, disruption_cost, buffer_cost, mitigation_cost]
-            }
-            
-            cost_df = pd.DataFrame(cost_data)
-            
-            fig_pie = px.pie(
-                cost_df, 
-                values='Amount (₹)', 
-                names='Category',
-                title="Cost Distribution Analysis"
-            )
-            st.plotly_chart(fig_pie, use_container_width=True)
-        
-        with col2:
-            st.markdown("**Cost Impact by Material Category:**")
-            
-            material_costs = df_demand.groupby('Material_Category').agg({
-                'Demand_Used': 'sum',
-                'Shortfall': 'sum'
-            })
-            
-            material_costs['Material_Cost'] = material_costs['Demand_Used'] * 150
-            material_costs['Shortage_Cost'] = material_costs['Shortfall'] * 300
-            material_costs['Total_Cost'] = material_costs['Material_Cost'] + material_costs['Shortage_Cost']
-            
-            fig_bar = px.bar(
-                material_costs.reset_index(),
-                x='Material_Category',
-                y=['Material_Cost', 'Shortage_Cost'],
-                title="Cost Analysis by Material Category",
-                labels={'value': 'Cost (₹)', 'variable': 'Cost Type'}
-            )
-            st.plotly_chart(fig_bar, use_container_width=True)
-        
-        # Cost optimization recommendations
-        st.markdown("**💡 Cost Optimization Recommendations:**")
-        
-        cost_savings_potential = disruption_cost * 0.6 + mitigation_cost * 0.4
-        st.markdown(f"""
-        <div class="metric-card">
-            <h4>Potential Annual Savings: ₹{cost_savings_potential:,.0f}</h4>
-            <ul>
-                <li><strong>Proactive Buffer Optimization:</strong> Reduce emergency costs by 40%</li>
-                <li><strong>Supplier Diversification:</strong> Lower disruption risk by 35%</li>
-                <li><strong>Predictive Analytics:</strong> Improve demand accuracy by 25%</li>
-                <li><strong>Automated Response:</strong> Reduce mitigation response time by 60%</li>
-            </ul>
-        </div>
-        """, unsafe_allow_html=True)
-
-# COMPLETE Enhanced External Signals Sidebar
+# External Signals Panel (same structure as original)
 st.sidebar.markdown("---")
-st.sidebar.markdown("""
-<div style="background: linear-gradient(135deg, #1f4e79, #2d5aa0); padding: 1rem; border-radius: 10px; margin-bottom: 1rem;">
-    <h3 style="color: white; margin: 0; text-align: center;">🌍 Market Intelligence Hub</h3>
-</div>
-""", unsafe_allow_html=True)
-
-# Enhanced external signals display
-for i, signal in enumerate(external_signals[:4]):  # Show top 4 signals
-    confidence_color = "#4CAF50" if signal['Confidence'] > 90 else "#FF9800" if signal['Confidence'] > 80 else "#F44336"
-    urgency_color = "#FF5722" if signal['Urgency'] == 'Immediate' else "#FF9800" if signal['Urgency'] == 'High' else "#4CAF50"
-    
+st.sidebar.subheader("🌍 External Market Signals")
+for signal in external_signals[:3]:
+    confidence_color = "green" if signal['Confidence'] > 90 else "orange" if signal['Confidence'] > 80 else "red"
     st.sidebar.markdown(f"""
-    <div class="external-signal" style="border-left: 3px solid {confidence_color};">
-        <div style="display: flex; justify-content: space-between; align-items: center;">
-            <strong style="color: {confidence_color};">{signal['Source']}</strong>
-            <span style="background: {urgency_color}; color: white; padding: 2px 6px; border-radius: 10px; font-size: 0.7em;">
-                {signal['Urgency']}
-            </span>
-        </div>
-        <p style="font-size: 0.85em; margin: 5px 0;">{signal['Signal']}</p>
-        <div style="font-size: 0.75em; color: #666;">
-            <strong>Impact:</strong> {signal['Impact']}<br>
-            <strong>Confidence:</strong> {signal['Confidence']}%<br>
-            <strong>Timeline:</strong> {signal['Timeline']}<br>
-            <strong>Estimated Impact:</strong> {signal['Estimated_Impact']}
-        </div>
+    <div style="background: white; padding: 8px; border-radius: 8px; margin: 8px 0; border-left: 3px solid {confidence_color};">
+        <strong style="color: {confidence_color};">{signal['Source']}</strong><br>
+        <small>{signal['Signal']}</small><br>
+        <small><strong>Impact:</strong> {signal['Impact']} ({signal['Confidence']}%)</small>
     </div>
     """, unsafe_allow_html=True)
 
-# Advanced system status
-st.sidebar.markdown("---")
-st.sidebar.markdown("### 🔧 System Status")
-
-system_status = {
-    "Data Pipeline": "🟢 Operational",
-    "AI Models": "🟢 Active",
-    "External APIs": "🟡 Partial",
-    "Alert System": "🟢 Running"
-}
-
-for system, status in system_status.items():
-    st.sidebar.markdown(f"**{system}:** {status}")
-
-st.sidebar.markdown(f"**Last Updated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-
-# COMPLETE Footer with advanced branding
+# Footer (same style as original)
 st.markdown("---")
 st.markdown("""
-<div style="text-align: center; padding: 30px; background: linear-gradient(135deg, #1f4e79, #2d5aa0); border-radius: 15px; color: white; margin-top: 30px;">
-    <h2 style="margin: 0;">🔌 Yazaki India Ltd</h2>
-    <h3 style="margin: 10px 0;">Advanced Supply Chain Command Center</h3>
-    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin: 20px 0;">
-        <div>
-            <h4 style="margin: 5px 0; color: #FFD700;">Planning Horizon</h4>
-            <p style="margin: 0;">8-Week Forward Visibility</p>
-        </div>
-        <div>
-            <h4 style="margin: 5px 0; color: #FFD700;">Intelligence</h4>
-            <p style="margin: 0;">AI-Enhanced Forecasting</p>
-        </div>
-        <div>
-            <h4 style="margin: 5px 0; color: #FFD700;">Coverage</h4>
-            <p style="margin: 0;">End-to-End Ecosystem</p>
-        </div>
-        <div>
-            <h4 style="margin: 5px 0; color: #FFD700;">Response</h4>
-            <p style="margin: 0;">Automated Mitigation</p>
-        </div>
-    </div>
-    <hr style="border: 1px solid rgba(255,255,255,0.3); margin: 20px 0;">
-    <p style="margin: 5px 0; font-style: italic;">
-        Electrical Components & Wire Harness Manufacturing Excellence
-    </p>
-    <p style="margin: 5px 0; font-size: 0.9em;">
-        <strong>Powered by Advanced Analytics | Machine Learning | Real-time Intelligence</strong>
-    </p>
-    <p style="margin: 5px 0; font-size: 0.8em; opacity: 0.8;">
-        Comprehensive Supply Chain Resilience Platform v3.0 | 2025
-    </p>
+<div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #1f4e79, #2d5aa0); border-radius: 15px; color: white;">
+    <h3>🔌 Yazaki India Ltd 8-Week Supply Chain Command Center</h3>
+    <p><strong>Firm + AI-Corrected Demand | Ecosystem Intelligence + Buffer Optimization</strong></p>
+    <p><em>Powered by Agentic AI | 8-Week Planning Horizon | Comprehensive Supply Chain Resilience</em></p>
 </div>
 """, unsafe_allow_html=True)