Touchpoint - complete idle analysis data

config_page.py

@@ -81,7 +81,7 @@ def initialize_session_state():
             MAX_PARALLEL_WORKERS, COST_LIST_PER_EMP_SHIFT,
             PAYMENT_MODE_CONFIG, LINE_CNT_PER_TYPE,
             MAX_EMPLOYEE_PER_TYPE_ON_DAY, start_date, end_date,
-            shift_code_to_name
+            shift_code_to_name, FIXED_MIN_UNICEF_PER_DAY
         )
         
         # Get the actual computed default values from optimization_config.py
@@ -97,6 +97,7 @@ def initialize_session_state():
             
             # Fixed staff configuration - from optimization_config.py
             'fixed_staff_mode': FIXED_STAFF_CONSTRAINT_MODE,
+            'fixed_min_unicef_per_day': FIXED_MIN_UNICEF_PER_DAY,
             
             # Payment configuration - from optimization_config.py
             'payment_mode_shift_1': PAYMENT_MODE_CONFIG.get(ShiftType.REGULAR),
@@ -236,6 +237,17 @@ def render_workforce_config():
             help="Maximum number of Humanizer employees per day"
         )
     
+    # Fixed minimum UNICEF requirement
+    st.subheader("🔒 Fixed Minimum Requirements")
+    
+    st.session_state.fixed_min_unicef_per_day = st.number_input(
+        "Fixed Minimum UNICEF per Day",
+        min_value=0,
+        max_value=20,
+        value=st.session_state.fixed_min_unicef_per_day,
+        help="Minimum number of UNICEF Fixed term employees required every working day (constraint)"
+    )
+    
     # Working hours configuration
     st.subheader("⏰ Working Hours Configuration")
     
@@ -520,6 +532,7 @@ def save_configuration():
         'workforce_limits': {
             'max_unicef_per_day': st.session_state.max_unicef_per_day,
             'max_humanizer_per_day': st.session_state.max_humanizer_per_day,
+            'fixed_min_unicef_per_day': st.session_state.fixed_min_unicef_per_day,
         },
         'working_hours': {
             'max_hour_per_person_per_day': st.session_state.max_hour_per_person_per_day,
@@ -598,6 +611,7 @@ def display_user_friendly_summary(config):
     with col1:
         st.write(f"**Max UNICEF Staff per Day:** {config['workforce_limits']['max_unicef_per_day']} people")
         st.write(f"**Max Humanizer Staff per Day:** {config['workforce_limits']['max_humanizer_per_day']} people")
+        st.write(f"**Fixed Minimum UNICEF per Day:** {config['workforce_limits']['fixed_min_unicef_per_day']} people")
     with col2:
         st.write(f"**Staff Management Mode:** {config['fixed_staff_mode'].replace('_', ' ').title()}")
         st.write(f"**Max Hours per Person per Day:** {config['working_hours']['max_hour_per_person_per_day']} hours")

optimization_results.py

@@ -8,6 +8,37 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 import sys
+import json
+
+# Load hierarchy data for enhanced visualization
+def load_kit_hierarchy():
+    """Load kit hierarchy data from JSON file"""
+    try:
+        with open('data/hierarchy_exports/kit_hierarchy.json', 'r') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+def get_kit_hierarchy_info(product):
+    """Get hierarchy level and dependencies for a product using main optimization system"""
+    try:
+        # Import from the main optimization system
+        from src.config.optimization_config import KIT_LEVELS, KIT_DEPENDENCIES
+        from src.config.constants import KitLevel
+        
+        # Use the same hierarchy system as the optimizer
+        if product in KIT_LEVELS:
+            level = KIT_LEVELS[product]
+            level_name = KitLevel.get_name(level)
+            dependencies = KIT_DEPENDENCIES.get(product, [])
+            return level_name, dependencies
+        else:
+            return 'unknown', []
+            
+    except Exception as e:
+        print(f"Error getting hierarchy info for {product}: {e}")
+        return 'unknown', []
+
 
 def display_optimization_results(results):
     """Display comprehensive optimization results with visualizations"""
@@ -64,6 +95,8 @@ def display_weekly_summary(results):
         # Calculate cost per unit
         cost_per_unit = total_cost / total_production if total_production > 0 else 0
         st.metric("Cost per Unit", f"€{cost_per_unit:.2f}")
+        
+    # Remove col5 - no idle employees metrics needed
     
     # Production vs Demand Chart
     st.subheader("🎯 Production vs Demand")
@@ -99,33 +132,131 @@ def display_weekly_summary(results):
         st.plotly_chart(fig, use_container_width=True)
 
 def display_daily_deep_dive(results):
-    """Display daily breakdown with workforce utilization"""
-    st.subheader("📅 Daily Workforce Utilization")
+    """Display daily breakdown with employee counts by type and shift"""
+    st.subheader("📅 Daily Employee Count by Type and Shift")
     
-    # Workforce utilization by day
-    workforce_data = []
-    for row in results['person_hours_by_day']:
-        workforce_data.append({
-            'Day': f"Day {row['day']}",
-            'Employee Type': row['emp_type'],
-            'Used Hours': row['used_person_hours'],
-            'Available Hours': row['cap_person_hours'],
-            'Utilization %': (row['used_person_hours'] / row['cap_person_hours'] * 100) if row['cap_person_hours'] > 0 else 0
-        })
+    # Transform schedule data to show employee counts by shift
+    employee_counts = []
     
-    df_workforce = pd.DataFrame(workforce_data)
-    
-    if not df_workforce.empty:
-        # Utilization percentage chart
-        fig = px.bar(df_workforce, x='Day', y='Utilization %', color='Employee Type',
-                    title='Daily Workforce Utilization by Employee Type',
-                    height=400)
-        fig.update_layout(yaxis_title='Utilization Percentage')
+    # Process the production schedule to extract employee usage by shift
+    # Only count employees when there's ACTUAL production work
+    for row in results['run_schedule']:
+        # Skip rows with no actual production activity
+        if row['run_hours'] <= 0 and row['units'] <= 0:
+            continue
+            
+        day = f"Day {row['day']}"
+        shift_name = {1: 'Regular', 2: 'Evening', 3: 'Overtime'}.get(row['shift'], f"Shift {row['shift']}")
+        
+        # Get team requirements for this production run
+        from src.config.optimization_config import TEAM_REQ_PER_PRODUCT
+        
+        for emp_type in ['UNICEF Fixed term', 'Humanizer']:
+            if row['product'] in TEAM_REQ_PER_PRODUCT.get(emp_type, {}):
+                employee_count = TEAM_REQ_PER_PRODUCT[emp_type][row['product']]
+                
+                # Only add if there are employees needed AND actual production occurs
+                if employee_count > 0 and (row['run_hours'] > 0 or row['units'] > 0):
+                    employee_counts.append({
+                        'Day': day,
+                        'Employee Type': emp_type,
+                        'Shift': shift_name,
+                        'Product': row['product'],
+                        'Employee Count': employee_count,
+                        'Hours Worked': row['run_hours'],
+                        'Total Person-Hours': employee_count * row['run_hours']
+                    })
+    
+    if employee_counts:
+        df_employees = pd.DataFrame(employee_counts)
+        
+        # Aggregate by day, employee type, and shift
+        df_summary = df_employees.groupby(['Day', 'Employee Type', 'Shift']).agg({
+            'Employee Count': 'sum',
+            'Total Person-Hours': 'sum'
+        }).reset_index()
+        
+        # Create stacked bar chart showing employee counts by shift
+        fig = px.bar(df_summary, 
+                    x='Day', 
+                    y='Employee Count', 
+                    color='Shift',
+                    facet_col='Employee Type',
+                    title='Daily Employee Count by Type and Shift',
+                    color_discrete_map={
+                        'Regular': '#32CD32',    # Green
+                        'Overtime': '#FF8C00',   # Orange
+                        'Evening': '#4169E1'     # Blue
+                    },
+                    height=500)
+        
+        fig.update_layout(
+            yaxis_title='Number of Employees',
+            showlegend=True
+        )
         st.plotly_chart(fig, use_container_width=True)
         
-        # Detailed table
-        st.subheader("📋 Daily Workforce Details")
-        st.dataframe(df_workforce, use_container_width=True)
+        # Detailed breakdown table
+        st.subheader("📋 Employee Allocation Details")
+        
+        # Show summary by day and shift with capacity context
+        st.markdown("**Summary by Day and Shift:**")
+        summary_pivot = df_summary.pivot_table(
+            values='Employee Count', 
+            index=['Day', 'Shift'], 
+            columns='Employee Type', 
+            aggfunc='sum', 
+            fill_value=0
+        ).reset_index()
+        
+        # Add capacity information
+        try:
+            from src.config.optimization_config import MAX_EMPLOYEE_PER_TYPE_ON_DAY
+            
+            # Add capacity columns
+            for emp_type in ['UNICEF Fixed term', 'Humanizer']:
+                if emp_type in summary_pivot.columns:
+                    capacity_col = f'{emp_type} Capacity'
+                    utilization_col = f'{emp_type} Utilization %'
+                    
+                    # Extract day number from 'Day X' format
+                    summary_pivot['Day_Num'] = summary_pivot['Day'].str.extract(r'(\d+)').astype(int)
+                    
+                    # Get capacity for each day
+                    summary_pivot[capacity_col] = summary_pivot['Day_Num'].apply(
+                        lambda day: MAX_EMPLOYEE_PER_TYPE_ON_DAY.get(emp_type, {}).get(day, 0)
+                    )
+                    
+                    # Calculate utilization percentage
+                    summary_pivot[utilization_col] = (
+                        summary_pivot[emp_type] / summary_pivot[capacity_col] * 100
+                    ).round(1)
+                    
+                    # Replace inf and NaN with 0
+                    summary_pivot[utilization_col] = summary_pivot[utilization_col].fillna(0)
+                    summary_pivot.loc[summary_pivot[capacity_col] == 0, utilization_col] = 0
+            
+            # Drop temporary column
+            summary_pivot = summary_pivot.drop('Day_Num', axis=1)
+            
+        except Exception as e:
+            print(f"Could not add capacity information: {e}")
+        
+        st.dataframe(summary_pivot, use_container_width=True)
+        
+        # Show detailed breakdown
+        st.markdown("**Detailed Production Assignments:**")
+        df_detailed = df_employees[['Day', 'Employee Type', 'Shift', 'Product', 'Employee Count', 'Hours Worked']].copy()
+        df_detailed = df_detailed.sort_values(['Day', 'Shift', 'Employee Type'])
+        st.dataframe(df_detailed, use_container_width=True)
+        
+    else:
+        st.info("📭 No employees scheduled - All production runs have zero hours and zero units")
+        
+        # Show debug info about filtered rows
+        total_schedule_rows = len(results.get('run_schedule', []))
+        if total_schedule_rows > 0:
+            st.markdown(f"*Note: {total_schedule_rows} schedule entries exist but all have zero production activity*")
 
 def display_line_schedules(results):
     """Display line schedules showing what runs when and with how many workers"""
@@ -134,7 +265,7 @@ def display_line_schedules(results):
     # Process schedule data
     schedule_data = []
     sys.path.append('src')
-    from config.optimization_config import TEAM_REQ_PER_PRODUCT, shift_code_to_name, line_code_to_name
+    from config.optimization_config import TEAM_REQ_PER_PRODUCT, shift_code_to_name, line_code_to_name, DEMAND_DICTIONARY
     
     # Get the mapping dictionaries
     shift_names = shift_code_to_name()
@@ -146,6 +277,9 @@ def display_line_schedules(results):
         humanizer_workers = TEAM_REQ_PER_PRODUCT.get('Humanizer', {}).get(row['product'], 0)
         total_workers = unicef_workers + humanizer_workers
         
+        # Get demand for this product
+        kit_total_demand = DEMAND_DICTIONARY.get(row['product'], 0)
+        
         # Convert codes to readable names
         line_name = line_names.get(row['line_type_id'], f"Line {row['line_type_id']}")
         shift_name = shift_names.get(row['shift'], f"Shift {row['shift']}")
@@ -155,6 +289,7 @@ def display_line_schedules(results):
             'Line': f"{line_name} {row['line_idx']}",
             'Shift': shift_name,
             'Product': row['product'],
+            'Kit Total Demand': kit_total_demand,
             'Hours': round(row['run_hours'], 2),
             'Units': round(row['units'], 0),
             'UNICEF Workers': unicef_workers,
@@ -165,20 +300,201 @@ def display_line_schedules(results):
     df_schedule = pd.DataFrame(schedule_data)
     
     if not df_schedule.empty:
-        # Timeline view
-        st.subheader("⏰ Production Timeline")
+        # Timeline view with hierarchy levels
+        st.subheader("⏰ Production Line by Line and Day")
         
-        # Create a Gantt-like chart
-        fig = px.bar(df_schedule, x='Hours', y='Line', color='Product',
-                    facet_col='Day', orientation='h',
-                    title='Production Schedule by Line and Day',
-                    height=500)
-        fig.update_layout(showlegend=True)
-        st.plotly_chart(fig, use_container_width=True)
+        # Add hierarchy information to the schedule data
+        for row in schedule_data:
+            hierarchy_level, dependencies = get_kit_hierarchy_info(row['Product'])
+            row['Hierarchy_Level'] = hierarchy_level
+            row['Dependencies'] = dependencies
+        
+        # Recreate dataframe with hierarchy info
+        df_schedule = pd.DataFrame(schedule_data)
         
-        # Detailed schedule table
+        # Create enhanced timeline chart with hierarchy colors
+        fig = create_enhanced_timeline_with_relationships(df_schedule)
+        
+        if fig:
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.warning("Could not create enhanced timeline chart")
+            
+        # Add hierarchy legend (updated to match fixed system)
+        st.markdown("""
+        **🎨 Hierarchy Level Colors:**
+        - 🟢 **Prepack**: Level 0 - Dependencies produced first (Lime Green)
+        - 🔵 **Subkit**: Level 1 - Intermediate assemblies (Royal Blue)
+        - 🟠 **Master**: Level 2 - Final products (Dark Orange)
+        """)
+        
+        # Detailed schedule table (filtered to show only meaningful rows)
         st.subheader("📋 Detailed Production Schedule")
-        st.dataframe(df_schedule, use_container_width=True)
+        
+        # Filter out rows with zero hours AND zero units (not useful)
+        df_schedule_filtered = df_schedule[
+            (df_schedule['Hours'] > 0) | (df_schedule['Units'] > 0)
+        ].copy()
+        
+        if df_schedule_filtered.empty:
+            st.warning("No production activity scheduled (all hours and units are zero)")
+        else:
+            # Show count of filtered vs total rows
+            filtered_count = len(df_schedule_filtered)
+            total_count = len(df_schedule)
+            if filtered_count < total_count:
+                st.info(f"Showing {filtered_count} active production entries (filtered out {total_count - filtered_count} zero-activity rows)")
+            
+            st.dataframe(df_schedule_filtered, use_container_width=True)
+
+def create_enhanced_timeline_with_relationships(df_schedule):
+    """Create enhanced timeline chart with hierarchy colors and relationship lines"""
+    if df_schedule.empty:
+        return None
+    
+    # Define hierarchy colors (using proper hierarchy levels with visible colors)
+    hierarchy_colors = {
+        'prepack': '#32CD32',         # Lime Green - Level 0 (dependencies)
+        'subkit': '#4169E1',          # Royal Blue - Level 1 (intermediate)
+        'master': '#FF8C00',          # Dark Orange - Level 2 (final products)
+        'unknown': '#8B0000'          # Dark Red - fallback (should not appear now)
+    }
+    
+    # Create the base chart using hierarchy levels for colors
+    fig = px.bar(df_schedule, 
+                x='Hours', 
+                y='Line', 
+                color='Hierarchy_Level',
+                facet_col='Day', 
+                orientation='h',
+                title='Production Schedule by Line and Day (Colored by Hierarchy Level)',
+                height=500,
+                color_discrete_map=hierarchy_colors,
+                hover_data=['Product', 'Units', 'Total Workers'])
+    
+    # Improve visibility with stronger borders and opacity
+    fig.update_traces(
+        marker_line_color='black',  # Add black borders
+        marker_line_width=1.5,      # Make borders visible
+        opacity=0.8                 # Slightly transparent but not too much
+    )
+    
+    # Improve layout with better text visibility
+    fig.update_layout(
+        showlegend=True,
+        plot_bgcolor='white',       # White background
+        paper_bgcolor='white',
+        font=dict(size=12, color='#000000', family='Arial, sans-serif'),  # Black text, clear font
+        title_font=dict(color='#000000', size=14, family='Arial Bold'),      # Bold black title
+        legend_title_text='Hierarchy Level',
+        legend=dict(
+            font=dict(size=11, color='#000000'),  # Black legend text
+            bgcolor='rgba(255,255,255,0.8)',      # Semi-transparent white background
+            bordercolor='#000000',                # Black border around legend
+            borderwidth=1
+        )
+    )
+    
+    # Improve axes with dark, bold text
+    fig.update_xaxes(
+        showgrid=True, 
+        gridwidth=0.5, 
+        gridcolor='lightgray',
+        title_font=dict(size=12, color='#000000'),
+        tickfont=dict(color='#000000', size=10)
+    )
+    fig.update_yaxes(
+        showgrid=True, 
+        gridwidth=0.5, 
+        gridcolor='lightgray',
+        title_font=dict(size=12, color='#000000'),
+        tickfont=dict(color='#000000', size=10)
+    )
+    
+    # Add dependency arrows/lines between related kits
+    try:
+        fig = add_dependency_connections(fig, df_schedule)
+    except Exception as e:
+        print(f"Could not add dependency connections: {e}")
+    
+    return fig
+
+def add_dependency_connections(fig, df_schedule):
+    """Add arrows or lines showing dependencies between kits"""
+    # Create a mapping of product to its position in the chart
+    product_positions = {}
+    
+    for _, row in df_schedule.iterrows():
+        product = row['Product']
+        day = row['Day']
+        line = row['Line']
+        
+        # Store position info
+        product_positions[product] = {
+            'day': day,
+            'line': line,
+            'dependencies': row.get('Dependencies', [])
+        }
+    
+    # Count relationships for display
+    relationship_count = 0
+    dependency_details = []
+    
+    for product, pos_info in product_positions.items():
+        dependencies = pos_info['dependencies']
+        
+        for dep in dependencies:
+            if dep in product_positions:
+                # Both product and dependency are in production
+                dep_pos = product_positions[dep]
+                relationship_count += 1
+                
+                dependency_details.append({
+                    'product': product,
+                    'dependency': dep,
+                    'product_day': pos_info['day'],
+                    'dependency_day': dep_pos['day'],
+                    'timing': 'correct' if dep_pos['day'] <= pos_info['day'] else 'violation'
+                })
+    
+    # Add annotations about relationships
+    if relationship_count > 0:
+        violations = len([d for d in dependency_details if d['timing'] == 'violation'])
+        
+        fig.add_annotation(
+            text=f"🔗 {relationship_count} dependencies | {'⚠️ ' + str(violations) + ' violations' if violations > 0 else '✅ All correct'}",
+            xref="paper", yref="paper",
+            x=0.02, y=0.98,
+            showarrow=False,
+            font=dict(size=10, color="purple"),
+            bgcolor="rgba(255,255,255,0.8)",
+            bordercolor="purple",
+            borderwidth=1
+        )
+        
+        # Add dependency info box
+        if dependency_details:
+            dependency_text = "\\n".join([
+                f"• {d['dependency']} → {d['product']} ({'✅' if d['timing'] == 'correct' else '⚠️'})"
+                for d in dependency_details[:5]  # Show first 5
+            ])
+            
+            if len(dependency_details) > 5:
+                dependency_text += f"\\n... and {len(dependency_details) - 5} more"
+                
+            fig.add_annotation(
+                text=dependency_text,
+                xref="paper", yref="paper",
+                x=0.02, y=0.02,
+                showarrow=False,
+                font=dict(size=8, color="navy"),
+                bgcolor="rgba(240,248,255,0.9)",
+                bordercolor="navy",
+                borderwidth=1,
+                align="left"
+            )
+    
+    return fig
 
 def display_kit_production(results):
     """Display kit production details"""
@@ -278,6 +594,43 @@ def display_cost_analysis(results):
                     'Cost': round(cost, 2)
                 })
     
+    # Add idle employee costs to the breakdown
+    if 'idle_employees' in results:
+        from config.optimization_config import COST_LIST_PER_EMP_SHIFT
+        
+        for idle in results['idle_employees']:
+            if idle['idle_count'] > 0:
+                emp_type = idle['emp_type']
+                shift = idle['shift']
+                day = idle['day']
+                idle_count = idle['idle_count']
+                
+                # Get hourly rate and shift name
+                hourly_rate = COST_LIST_PER_EMP_SHIFT.get(emp_type, {}).get(shift, 0)
+                shift_name = shift_names.get(shift, f"Shift {shift}")
+                
+                # Idle employees work 0 hours but get paid for full shift
+                actual_hours = 0
+                paid_hours = 7.5  # Assuming standard shift length
+                idle_cost = idle_count * paid_hours * hourly_rate
+                
+                if emp_type not in total_cost_by_type:
+                    total_cost_by_type[emp_type] = 0
+                total_cost_by_type[emp_type] += idle_cost
+                
+                cost_data.append({
+                    'Employee Type': emp_type,
+                    'Day': f"Day {day}",
+                    'Shift': f"{shift_name} (Idle)",
+                    'Line': '-',  # No line assignment for idle
+                    'Product': '-',  # No product for idle
+                    'Actual Hours': actual_hours,
+                    'Paid Hours': round(paid_hours, 2),
+                    'Workers': int(idle_count),
+                    'Hourly Rate': f"€{hourly_rate:.2f}",
+                    'Cost': round(idle_cost, 2)
+                })
+    
     # Total cost metrics
     total_cost = results['objective']
     col1, col2, col3, col4 = st.columns(4)
@@ -307,5 +660,25 @@ def display_cost_analysis(results):
     # Detailed cost table
     if cost_data:
         df_costs = pd.DataFrame(cost_data)
+        
+        # Add total row
+        total_cost = df_costs['Cost'].sum()
+        total_paid_hours = df_costs['Paid Hours'].sum() if 'Paid Hours' in df_costs.columns else df_costs['Actual Hours'].sum()
+        total_row = pd.DataFrame([{
+            'Employee Type': '**TOTAL**',
+            'Day': '-',
+            'Shift': '-',
+            'Line': '-',
+            'Product': '-', 
+            'Actual Hours': df_costs['Actual Hours'].sum(),
+            'Paid Hours': total_paid_hours,
+            'Workers': df_costs['Workers'].sum(),
+            'Hourly Rate': '-',
+            'Cost': total_cost
+        }])
+        
+        # Combine original data with total row
+        df_costs_with_total = pd.concat([df_costs, total_row], ignore_index=True)
+        
         st.subheader("📋 Detailed Cost Breakdown")
-        st.dataframe(df_costs, use_container_width=True)
+        st.dataframe(df_costs_with_total, use_container_width=True)

src/config/constants.py

@@ -96,15 +96,8 @@ class KitLevel:
             cls.MASTER: "master"
         }
     
-    @classmethod
-    def get_timing_weight(cls, level_id):
-        """Get timing weight for hierarchy optimization"""
-        weights = {
-            cls.PREPACK: 0.1,
-            cls.SUBKIT: 0.5, 
-            cls.MASTER: 1.0
-        }
-        return weights.get(level_id, 1.0)
+    # Removed get_timing_weight method - no longer needed
+    # Dependency ordering is now handled by topological sorting
 
 class PaymentMode:
     """

src/config/optimization_config.py

@@ -382,6 +382,25 @@ DAILY_WEEKLY_SCHEDULE = "daily"  # daily or weekly ,this needs to be implemented
 #   "none"      - Purely demand-driven scheduling (cost-efficient)
 FIXED_STAFF_CONSTRAINT_MODE = "priority"  # Recommended: "priority" for realistic business model
 
+def get_fixed_min_unicef_per_day():
+    """
+    Get fixed minimum UNICEF employees per day - try from streamlit session state first, then default
+    This ensures a minimum number of UNICEF fixed-term staff are present every working day
+    """
+    try:
+        import streamlit as st
+        if hasattr(st, 'session_state') and 'fixed_min_unicef_per_day' in st.session_state:
+            print(f"Using fixed minimum UNICEF per day from config page: {st.session_state.fixed_min_unicef_per_day}")
+            return st.session_state.fixed_min_unicef_per_day
+    except ImportError:
+        pass  # Streamlit not available in CLI mode
+    
+    # Default value - minimum UNICEF Fixed term employees required per day
+    return 2
+
+# Set the constant for backward compatibility
+FIXED_MIN_UNICEF_PER_DAY = get_fixed_min_unicef_per_day()
+
 
 def get_payment_mode_config():
     """

src/models/optimizer_real.py

@@ -26,7 +26,7 @@ from src.config.optimization_config import (
     MAX_HOUR_PER_SHIFT_PER_PERSON,   # {1: hours, 2: hours, 3: hours}
     PER_PRODUCT_SPEED,           # {6: cap_units_per_hour, 7: cap_units_per_hour}
     MAX_PARALLEL_WORKERS,            # {6: max_workers, 7: max_workers}
-    DAILY_WEEKLY_SCHEDULE,           # 'daily' or 'weekly' (여기선 weekly로 모델링)
+    DAILY_WEEKLY_SCHEDULE,           # 'daily' or 'weekly' 
     FIXED_STAFF_CONSTRAINT_MODE,     # not used in fixed-team model (동시 투입이라 무의미)
     TEAM_REQ_PER_PRODUCT,            # {emp_type: {product: team_size}} from Kits_Calculation.csv
     PAYMENT_MODE_CONFIG,             # {shift: 'bulk'/'partial'} payment mode configuration
@@ -37,6 +37,8 @@ from src.config.optimization_config import (
     KIT_LEVELS,                      # {kit_id: level} where 0=prepack, 1=subkit, 2=master
     KIT_DEPENDENCIES,                # {kit_id: [dependency_list]}
     PRODUCTION_PRIORITY_ORDER,       # [kit_ids] sorted by production priority
+    # Fixed staffing requirements
+    FIXED_MIN_UNICEF_PER_DAY,        # Minimum UNICEF employees required per day
 )
 
 # -----------------------------------------
@@ -70,9 +72,12 @@ print("PER_PRODUCT_SPEED",PER_PRODUCT_SPEED)
 
 def sort_products_by_hierarchy(product_list):
     """
-    Sort products by hierarchy levels and dependencies.
+    Sort products by hierarchy levels and dependencies using topological sorting.
     Returns products in optimal production order: prepacks → subkits → masters
+    Dependencies within the same level are properly ordered.
     """
+    from collections import defaultdict, deque
+    
     # Filter products that are in our production list and have hierarchy data
     products_with_hierarchy = [p for p in product_list if p in KIT_LEVELS]
     products_without_hierarchy = [p for p in product_list if p not in KIT_LEVELS]
@@ -80,32 +85,78 @@ def sort_products_by_hierarchy(product_list):
     if products_without_hierarchy:
         print(f"[HIERARCHY] Products without hierarchy data: {products_without_hierarchy}")
     
-    # Sort by hierarchy level (0=prepack, 1=subkit, 2=master) then by product ID
-    sorted_products = sorted(products_with_hierarchy, 
-                           key=lambda p: (KIT_LEVELS.get(p, 999), p))
+    # Build dependency graph for products in our list
+    graph = defaultdict(list)  # product -> [dependents]
+    in_degree = defaultdict(int)  # product -> number of dependencies
+    
+    # Initialize all products
+    for product in products_with_hierarchy:
+        in_degree[product] = 0
+    
+    # Build edges based on actual dependencies
+    dependency_count = 0
+    for product in products_with_hierarchy:
+        deps = KIT_DEPENDENCIES.get(product, [])
+        for dep in deps:
+            if dep in products_with_hierarchy:  # Only if dependency is in our production list
+                graph[dep].append(product)  # dep -> product
+                in_degree[product] += 1
+                dependency_count += 1
+    
+    print(f"[HIERARCHY] Found {dependency_count} dependency relationships in production list")
+    
+    # Topological sort with hierarchy level priority
+    sorted_products = []
+    queue = deque()
+    
+    # Start with products that have no dependencies, prioritized by hierarchy level
+    no_deps = [(KIT_LEVELS.get(p, 999), p) for p in products_with_hierarchy if in_degree[p] == 0]
+    no_deps.sort()  # Sort by (level, product_id)
+    
+    for _, product in no_deps:
+        queue.append(product)
+    
+    while queue:
+        current = queue.popleft()
+        sorted_products.append(current)
+        
+        # Process dependents
+        dependents = [(KIT_LEVELS.get(dep, 999), dep) for dep in graph[current]]
+        dependents.sort()  # Sort by hierarchy level first
+        
+        for _, dependent in dependents:
+            in_degree[dependent] -= 1
+            if in_degree[dependent] == 0:
+                queue.append(dependent)
+    
+    # Check for cycles (shouldn't happen with proper hierarchy)
+    if len(sorted_products) != len(products_with_hierarchy):
+        remaining = [p for p in products_with_hierarchy if p not in sorted_products]
+        print(f"[HIERARCHY] WARNING: Potential circular dependencies detected in: {remaining}")
+        # Add remaining products sorted by level as fallback
+        remaining_sorted = sorted(remaining, key=lambda p: (KIT_LEVELS.get(p, 999), p))
+        sorted_products.extend(remaining_sorted)
     
     # Add products without hierarchy at the end
     sorted_products.extend(sorted(products_without_hierarchy))
     
-    print(f"[HIERARCHY] Production order: {len(sorted_products)} products")
+    print(f"[HIERARCHY] Dependency-aware production order: {len(sorted_products)} products")
     for i, p in enumerate(sorted_products[:10]):  # Show first 10
         level = KIT_LEVELS.get(p, "unknown")
         level_name = KitLevel.get_name(level)
         deps = KIT_DEPENDENCIES.get(p, [])
-        print(f"  {i+1}. {p} (level {level}={level_name}, deps: {len(deps)})")
+        deps_in_list = [d for d in deps if d in products_with_hierarchy]
+        print(f"  {i+1}. {p} (level {level}={level_name}, deps: {len(deps_in_list)})")
+        if deps_in_list:
+            print(f"      Dependencies: {deps_in_list}")
     
     if len(sorted_products) > 10:
         print(f"  ... and {len(sorted_products) - 10} more products")
     
     return sorted_products
 
-def get_dependency_timing_weight(product):
-    """
-    Calculate timing weight based on hierarchy level.
-    Lower levels (prepacks) should be produced earlier.
-    """
-    level = KIT_LEVELS.get(product, KitLevel.MASTER)  # Default to master level
-    return KitLevel.get_timing_weight(level)
+# Removed get_dependency_timing_weight function - no longer needed
+# Dependency ordering is now handled by topological sorting in sort_products_by_hierarchy()
 
 def solve_fixed_team_weekly():
     # --- Sets ---
@@ -196,6 +247,14 @@ def solve_fixed_team_weekly():
                     Z[p, ell, s, t] = solver.BoolVar(f"Z_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
                     T[p, ell, s, t] = solver.NumVar(0, Hmax_s[s], f"T_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
                     U[p, ell, s, t] = solver.NumVar(0, INF,       f"U_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
+    
+    # Idle employee variables: IDLE[e,s,t] = number of idle employees of type e in shift s on day t
+    IDLE = {}
+    for e in E:
+        for s in S:
+            for t in D:
+                max_idle = N_day[e][t]  # Can't have more idle employees than available
+                IDLE[e, s, t] = solver.IntVar(0, max_idle, f"IDLE_{e}_s{s}_d{t}")
 
     # Note: Binary variables for bulk payment are now created inline in the cost calculation
 
@@ -237,25 +296,30 @@ def solve_fixed_team_weekly():
                             # Cost: pay the specific working employees for full shift hours
                             cost_terms.append(cost[e][s] * Hmax_s[s] * TEAM_REQ_PER_PRODUCT[e][p] * work_binary)
     
-    total_cost = solver.Sum(cost_terms)
+    # Add idle employee costs (idle employees are paid for full shift hours)
+    for e in E:
+        for s in S:
+            for t in D:
+                cost_terms.append(cost[e][s] * Hmax_s[s] * IDLE[e, s, t])
     
-    # Secondary objective: encourage earlier production of dependencies (soft constraint)
-    # Small weight (0.01) to prioritize hierarchy without overwhelming cost optimization
-    hierarchy_penalty = solver.Sum(
-        0.01 * get_dependency_timing_weight(p) * t * T[p, ell, s, t]
-        for p in P for ell in L for s in S for t in D
-    )
+    total_cost = solver.Sum(cost_terms)
     
-    total_objective = total_cost + hierarchy_penalty
-    solver.Minimize(total_objective)
+    # Objective: minimize total cost only
+    # Dependency ordering is handled by topological sorting and hard constraints
+    solver.Minimize(total_cost)
 
     # --- Constraints ---
 
-    # 1) Weekly demand
+    # 1) Weekly demand - must meet exactly (no over/under production)
     for p in P:
-        solver.Add(
-            solver.Sum(U[p, ell, s, t] for ell in L for s in S for t in D) >= d_week.get(p, 0)
-        )
+        total_production = solver.Sum(U[p, ell, s, t] for ell in L for s in S for t in D)
+        demand = d_week.get(p, 0)
+        
+        # Must produce at least the demand
+        solver.Add(total_production >= demand)
+        
+        # Must not produce more than the demand (prevent overproduction)
+        solver.Add(total_production <= demand)
 
     # 2) One product per (line,shift,day) + time gating
     for ell in L:
@@ -287,21 +351,36 @@ def solve_fixed_team_weekly():
                     if p in PER_PRODUCT_SPEED:
                         # Convert kit per day to kit per hour (assuming 7.5 hour workday)
                         speed = PER_PRODUCT_SPEED[p] 
+                        # Upper bound: units cannot exceed capacity
                         solver.Add(
                             U[p, ell, s, t] <= speed * T[p, ell, s, t]
                         )
+                        # Lower bound: if working, must produce (prevent phantom work)
+                        solver.Add(
+                            U[p, ell, s, t] >= speed * T[p, ell, s, t]
+                        )
                     else:
                         # Default speed if not found
                         default_speed = 800 / 7.5  # units per hour
                         print(f"Warning: No speed data for product {p}, using default {default_speed:.1f} per hour")
+                        # Upper bound: units cannot exceed capacity
                         solver.Add(
                             U[p, ell, s, t] <= default_speed * T[p, ell, s, t]
                         )
+                        # Lower bound: if working, must produce (prevent phantom work)
+                        solver.Add(
+                            U[p, ell, s, t] >= default_speed * T[p, ell, s, t]
+                        )
 
-    # 5) Per-shift staffing capacity by type: sum(req*hours) ≤ shift_hours * headcount
+    # 5) Per-shift staffing capacity by type: idle employees ≤ available headcount
     for e in E:
         for s in S:
             for t in D:
+                # Idle employees cannot exceed available headcount
+                # (Active employees are constrained by the working hours constraint below)
+                solver.Add(IDLE[e, s, t] <= N_day[e][t])
+                
+                # Working hours constraint: active employees cannot exceed shift hour capacity
                 solver.Add(
                     solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, s, t] for p in P for ell in L)
                     <= Hmax_s[s] * N_day[e][t]
@@ -326,18 +405,87 @@ def solve_fixed_team_weekly():
                     solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, ShiftType.REGULAR, t] for p in P for ell in L)
                 )
     
-    # Overtime shift after regular shift
+    # Overtime should only be used when regular shift is at capacity
     if ShiftType.OVERTIME in S and ShiftType.REGULAR in S:  # Only if both shifts are available
+        print("\n[OVERTIME] Adding constraints to ensure overtime only when regular shift is insufficient...")
+        
         for e in E:
             for t in D:
-                solver.Add(
-                    solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, ShiftType.OVERTIME, t] for p in P for ell in L)
-                    <=
-                    solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, ShiftType.REGULAR, t] for p in P for ell in L)
+                # Get available regular capacity for this employee type and day
+                regular_capacity = N_day[e][t]
+                
+                # Total regular shift usage for this employee type and day
+                regular_usage = solver.Sum(
+                    TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, ShiftType.REGULAR, t] 
+                    for p in P for ell in L
+                )
+                
+                # Total overtime usage for this employee type and day
+                overtime_usage = solver.Sum(
+                    TEAM_REQ_PER_PRODUCT[e][p] * T[p, ell, ShiftType.OVERTIME, t] 
+                    for p in P for ell in L
                 )
+                
+                # Create binary variable: 1 if using overtime, 0 otherwise
+                using_overtime = solver.IntVar(0, 1, f'using_overtime_{e}_{t}')
+                
+                # If using overtime, regular capacity must be utilized significantly
+                # Regular usage must be at least 90% of capacity to allow overtime
+                min_regular_for_overtime = int(0.9 * regular_capacity)
+                
+                # Constraint 1: Can only use overtime if regular usage is high
+                solver.Add(regular_usage >= min_regular_for_overtime * using_overtime)
+                
+                # Constraint 2: If any overtime is used, set the binary variable
+                solver.Add(overtime_usage <= regular_capacity * using_overtime)
+                
+        overtime_constraints_added = len(E) * len(D) * 2  # 2 constraints per employee type per day
+        print(f"[OVERTIME] Added {overtime_constraints_added} constraints ensuring overtime only when regular shifts are at 90%+ capacity")
     
     # 7.5) Bulk payment linking constraints are now handled inline in the cost calculation
     
+    # 7.6) *** FIXED MINIMUM UNICEF EMPLOYEES CONSTRAINT ***
+    # Ensure minimum UNICEF fixed-term staff are present every working day
+    if 'UNICEF Fixed term' in E and FIXED_MIN_UNICEF_PER_DAY > 0:
+        print(f"\n[FIXED STAFFING] Adding constraint for minimum {FIXED_MIN_UNICEF_PER_DAY} UNICEF employees per day...")
+        
+        unicef_constraints_added = 0
+        for t in D:
+            # Method 1: Simple approach - ensure minimum UNICEF employees are scheduled
+            # regardless of whether they're working or idle
+            # Sum up all possible UNICEF work assignments + idle UNICEF employees
+            
+            # Count all UNICEF work hours across all products, lines, and shifts
+            all_unicef_hours = solver.Sum(
+                TEAM_REQ_PER_PRODUCT.get('UNICEF Fixed term', {}).get(p, 0) * T[p, ell, s, t]
+                for p in P
+                for ell in L 
+                for s in S
+            )
+            
+            # Count idle UNICEF employees across all shifts
+            idle_unicef_employees = solver.Sum(
+                IDLE['UNICEF Fixed term', s, t] for s in S
+            )
+            
+            # Constraint: total hours (work + idle*14) must meet minimum staffing
+            # This ensures at least FIXED_MIN_UNICEF_PER_DAY employees are present
+            solver.Add(all_unicef_hours + idle_unicef_employees * MAX_HOUR_PER_PERSON_PER_DAY >= FIXED_MIN_UNICEF_PER_DAY * MAX_HOUR_PER_PERSON_PER_DAY)
+            
+            # Additional constraint: ensure idle employees are properly linked to total headcount
+            # This prevents the solver from avoiding the minimum by setting everyone to zero
+            total_unicef_hours_needed_for_production = solver.Sum(
+                TEAM_REQ_PER_PRODUCT.get('UNICEF Fixed term', {}).get(p, 0) * T[p, ell, s, t]
+                for p in P for ell in L for s in S
+            )
+            
+            # Simpler approach: just ensure the basic constraint is strong enough
+            # The main constraint above should be sufficient: all_unicef_hours + idle*14 >= min*14
+            # This already forces idle employees when production is insufficient
+            unicef_constraints_added += 1
+            
+        print(f"[FIXED STAFFING] Added {unicef_constraints_added} constraints ensuring >= {FIXED_MIN_UNICEF_PER_DAY} UNICEF employees per day")
+    
     # 8) *** HIERARCHY DEPENDENCY CONSTRAINTS ***
     # For subkits with prepack dependencies: dependencies should be produced before or same time
     print("\n[HIERARCHY] Adding dependency constraints...")
@@ -425,6 +573,21 @@ def solve_fixed_team_weekly():
                               'cap_person_hours': Hmax_daily * N_day[e][t]})
     result['person_hours_by_day'] = ph_by_day
 
+    # Idle employee data for visualization
+    idle_employees = []
+    for e in E:
+        for s in S:
+            for t in D:
+                idle_count = IDLE[e, s, t].solution_value()
+                if idle_count > 0:  # Only include non-zero idle counts
+                    idle_employees.append({
+                        'emp_type': e,
+                        'shift': s,
+                        'day': t,
+                        'idle_count': idle_count
+                    })
+    result['idle_employees'] = idle_employees
+
     # Pretty print
     print("Objective (min cost):", result['objective'])
     print("\n--- Weekly production by product ---")
@@ -449,6 +612,20 @@ def solve_fixed_team_weekly():
         print(f"{row['emp_type']}, D{row['day']}: used={row['used_person_hours']:.1f} "
               f"(cap {row['cap_person_hours']})")
 
+    # Report idle employees
+    print("\n--- Idle employees (per type/shift/day) ---")
+    idle_found = False
+    for e in E:
+        for s in S:
+            for t in D:
+                idle_count = IDLE[e, s, t].solution_value()
+                if idle_count > 0:
+                    shift_name = ShiftType.get_name(s)
+                    print(f"{e}, {shift_name}, D{t}: idle={idle_count}")
+                    idle_found = True
+    if not idle_found:
+        print("No idle employees scheduled")
+
     return result
 
 

src/visualization/hierarchy_dashboard.py

@@ -0,0 +1,555 @@
+"""
+Hierarchy-Based Production Flow Visualization
+Shows how kits flow through production based on dependency hierarchy
+"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+try:
+    import networkx as nx
+    NETWORKX_AVAILABLE = True
+except ImportError:
+    NETWORKX_AVAILABLE = False
+    nx = None
+
+import numpy as np
+import sys
+sys.path.append('src')
+
+from config.optimization_config import (
+    KIT_LEVELS, KIT_DEPENDENCIES, TEAM_REQ_PER_PRODUCT, 
+    shift_code_to_name, line_code_to_name
+)
+from config.constants import ShiftType, LineType, KitLevel
+
+# Import kit relationships dashboard
+try:
+    from src.visualization.kit_relationships import display_kit_relationships_dashboard
+except ImportError:
+    display_kit_relationships_dashboard = None
+
+def display_hierarchy_operations_dashboard(results):
+    """Enhanced operations dashboard showing hierarchy-based production flow"""
+    st.header("🏭 Hierarchy-Based Operations Dashboard")
+    st.markdown("---")
+    
+    # Create main dashboard tabs
+    tab1, tab2, tab3 = st.tabs([
+        "🔄 Production Flow", 
+        "📊 Hierarchy Analytics", 
+        "🔗 Kit Relationships"
+    ])
+    
+    with tab1:
+        display_production_flow_visualization(results)
+    
+    with tab2:
+        display_hierarchy_analytics(results)
+    
+    with tab3:
+        # Kit relationships from actual hierarchy data
+        if display_kit_relationships_dashboard:
+            display_kit_relationships_dashboard(results)
+        else:
+            st.error("Kit relationships dashboard not available. Please check installation.")
+
+def display_production_flow_visualization(results):
+    """Show how products flow through production lines by hierarchy"""
+    st.subheader("🔄 Kit Production Flow by Hierarchy")
+    
+    # Get production sequence data
+    flow_data = prepare_hierarchy_flow_data(results)
+    
+    if not flow_data:
+        st.warning("No production data available for flow visualization")
+        return
+    
+    # Create flow diagram
+    
+    
+
+    # Hierarchy level summary - horizontal layout
+    st.subheader("📦 Production by Level")
+    level_summary = get_hierarchy_level_summary(flow_data)
+    
+    # Create horizontal columns for each level
+    level_names = ['prepack', 'subkit', 'master']
+    available_levels = [level for level in level_names if level in level_summary]
+    
+    if available_levels:
+        cols = st.columns(len(available_levels))
+        
+        for i, level_name in enumerate(available_levels):
+            data = level_summary[level_name]
+            with cols[i]:
+                # Use custom styling instead of st.metric to avoid delta arrows
+                st.markdown(f"""
+                <div style="
+                    background: linear-gradient(135deg, #f0f8ff, #e6f3ff);
+                    padding: 1rem;
+                    border-radius: 0.5rem;
+                    text-align: center;
+                    border-left: 4px solid {'#90EE90' if level_name == 'prepack' else '#FFD700' if level_name == 'subkit' else '#FF6347'};
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                ">
+                    <div style="font-size: 0.8rem; color: #666; text-transform: uppercase; letter-spacing: 1px;">
+                        {level_name.title()} Kits
+                    </div>
+                    <div style="font-size: 1.5rem; font-weight: bold; color: #333; margin: 0.2rem 0;">
+                        {data['count']} products
+                    </div>
+                    <div style="font-size: 1rem; color: #555;">
+                        {data['total_units']:,.0f} units
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+    
+    # Timeline view of hierarchy production
+    st.subheader("📅 Hierarchy Production Timeline")
+    try:
+        fig_timeline = create_hierarchy_timeline(flow_data)
+        st.plotly_chart(fig_timeline, use_container_width=True)
+    except Exception as e:
+        st.warning(f"Timeline chart temporarily unavailable. Showing alternative visualization.")
+        # Fallback: Simple bar chart by day
+        if flow_data:
+            df_simple = pd.DataFrame([{
+                'Day': f"Day {row['day']}",
+                'Level': row['level_name'].title(),
+                'Units': row['units'],
+                'Product': row['product']
+            } for row in flow_data])
+            
+            fig_simple = px.bar(df_simple, x='Day', y='Units', color='Level',
+                               title='Production Volume by Day and Hierarchy Level',
+                               color_discrete_map={
+                                   'Prepack': '#90EE90',
+                                   'Subkit': '#FFD700', 
+                                   'Master': '#FF6347'
+                               })
+            st.plotly_chart(fig_simple, use_container_width=True)
+
+def display_hierarchy_analytics(results):
+    """Deep dive analytics on hierarchy production performance"""
+    st.subheader("📊 Hierarchy Performance Analytics")
+    
+    # Prepare analytics data
+    analytics_data = prepare_hierarchy_analytics_data(results)
+    
+    if not analytics_data:
+        st.warning("No hierarchy data available for analytics")
+        return
+    
+    # Key metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        prepack_efficiency = analytics_data.get('prepack_efficiency', 0)
+        st.metric("Prepack Efficiency", f"{prepack_efficiency:.1f}%", 
+                 delta=f"{prepack_efficiency-95:.1f}%" if prepack_efficiency != 95 else None)
+    
+    with col2:
+        dependency_violations = analytics_data.get('dependency_violations', 0)
+        st.metric("Dependency Violations", f"{dependency_violations}", 
+                 delta=f"-{dependency_violations}" if dependency_violations > 0 else None)
+    
+    with col3:
+        avg_lead_time = analytics_data.get('avg_lead_time', 0)
+        st.metric("Avg Lead Time", f"{avg_lead_time:.1f} days")
+    
+    with col4:
+        hierarchy_cost_efficiency = analytics_data.get('cost_efficiency', 0)
+        st.metric("Cost Efficiency", f"€{hierarchy_cost_efficiency:.2f}/unit")
+    
+    # Dependency flow chart
+    st.subheader("🔗 Dependency Network Analysis")
+    fig_network = create_dependency_network_chart(analytics_data)
+    st.plotly_chart(fig_network, use_container_width=True)
+    
+    # Production heatmap
+    st.subheader("🔥 Hierarchy Production Heatmap")
+    heatmap_fig = create_hierarchy_heatmap(results)
+    st.plotly_chart(heatmap_fig, use_container_width=True)
+    
+
+
+# Removed display_enhanced_line_utilization function - utilization concept removed
+
+def display_production_sequence_analysis(results):
+    """Analyze production sequence and timing"""
+    st.subheader("🎯 Production Sequence Analysis")
+    
+    
+    if not sequence_data:
+        st.warning("No sequence data available")
+        return
+    
+    # Sequence adherence metrics
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        sequence_score = sequence_data.get('sequence_adherence_score', 0)
+        st.metric("Sequence Adherence", f"{sequence_score:.1f}%",
+                 help="How well production follows optimal hierarchy sequence")
+    
+    with col2:
+        early_productions = sequence_data.get('early_productions', 0)
+        st.metric("Early Productions", f"{early_productions}",
+                 help="Products produced before their dependencies")
+    
+    with col3:
+        optimal_sequences = sequence_data.get('optimal_sequences', 0)
+        st.metric("Optimal Sequences", f"{optimal_sequences}%",
+                 help="Percentage of products following optimal sequence")
+    
+    # Sequence violation chart
+    if sequence_data.get('violations'):
+        st.subheader("⚠️ Sequence Violations")
+        violations_df = pd.DataFrame(sequence_data['violations'])
+        
+        fig = px.scatter(violations_df, 
+                        x='production_day', y='dependency_day', 
+                        color='severity', size='impact',
+                        hover_data=['product', 'dependency'],
+                        title='Production vs Dependency Timing (Violations in Red)',
+                        labels={'production_day': 'When Product Was Made',
+                               'dependency_day': 'When Dependency Was Made'})
+        
+        # Add diagonal line (should be above this line)
+        max_day = max(violations_df['production_day'].max(), violations_df['dependency_day'].max())
+        fig.add_shape(type="line", x0=0, y0=0, x1=max_day, y1=max_day,
+                     line=dict(dash="dash", color="gray"),
+                     name="Ideal Sequence Line")
+        
+        st.plotly_chart(fig, use_container_width=True)
+    
+    # Sequence optimization suggestions
+    st.subheader("💡 Optimization Suggestions")
+    suggestions = generate_sequence_suggestions(sequence_data)
+    for suggestion in suggestions:
+        st.info(f"💡 {suggestion}")
+
+# Helper Functions
+
+def prepare_hierarchy_flow_data(results):
+    """Prepare data for hierarchy flow visualization"""
+    flow_data = []
+    
+    for row in results['run_schedule']:
+        product = row['product']
+        level = KIT_LEVELS.get(product, KitLevel.MASTER)
+        level_name = KitLevel.get_name(level)
+        
+        flow_data.append({
+            'product': product,
+            'level': level,
+            'level_name': level_name,
+            'day': row['day'],
+            'shift': row['shift'],
+            'line_type': row['line_type_id'],
+            'line_idx': row['line_idx'],
+            'hours': row['run_hours'],
+            'units': row['units'],
+            'dependencies': KIT_DEPENDENCIES.get(product, [])
+        })
+    
+    return flow_data
+
+def create_hierarchy_timeline(flow_data):
+    """Create timeline showing hierarchy production sequence"""
+    if not flow_data:
+        return go.Figure()
+    
+    # Prepare timeline data with proper datetime conversion
+    timeline_data = []
+    
+    from datetime import datetime, timedelta
+    base_date = datetime(2025, 1, 1)  # Base date for timeline
+    
+    for row in flow_data:
+        shift_name = ShiftType.get_name(row['shift'])
+        line_name = LineType.get_name(row['line_type'])
+        
+        # Create start and end times for the production run
+        start_date = base_date + timedelta(days=row['day']-1)
+        end_date = start_date + timedelta(hours=row['hours'])
+        
+        timeline_data.append({
+            'Product': row['product'],
+            'Level': row['level_name'].title(),
+            'Start': start_date,
+            'End': end_date,
+            'Day': f"Day {row['day']}",
+            'Shift': shift_name,
+            'Line': f"{line_name} {row['line_idx']}",
+            'Units': row['units'],
+            'Hours': row['hours'],
+            'Priority': row['level']  # For sorting
+        })
+    
+    df = pd.DataFrame(timeline_data)
+    
+    if df.empty:
+        return go.Figure()
+    
+    # Create timeline chart with proper datetime columns
+    fig = px.timeline(df, 
+                     x_start='Start', x_end='End',
+                     y='Line', 
+                     color='Level',
+                     hover_data=['Product', 'Units', 'Hours', 'Shift', 'Day'],
+                     title='Production Timeline by Hierarchy Level',
+                     color_discrete_map={
+                         'Prepack': '#90EE90',
+                         'Subkit': '#FFD700', 
+                         'Master': '#FF6347'
+                     })
+    
+    fig.update_layout(
+        height=500,
+        xaxis_title='Production Timeline',
+        yaxis_title='Production Line'
+    )
+    
+    return fig
+
+def prepare_hierarchy_analytics_data(results):
+    """Prepare analytics data for hierarchy performance"""
+    analytics = {
+        'prepack_efficiency': 0,
+        'dependency_violations': 0,
+        'avg_lead_time': 0,
+        'cost_efficiency': 0,
+        'violations': [],
+        'dependencies': KIT_DEPENDENCIES
+    }
+    
+    # Calculate metrics
+    total_cost = results.get('objective', 0)
+    total_units = sum(results.get('weekly_production', {}).values())
+    
+    if total_units > 0:
+        analytics['cost_efficiency'] = total_cost / total_units
+    
+    # Analyze dependency violations
+    production_times = {}
+    for row in results['run_schedule']:
+        product = row['product']
+        day = row['day']
+        if product not in production_times or day < production_times[product]:
+            production_times[product] = day
+    
+    violations = 0
+    violation_details = []
+    
+    for product, prod_day in production_times.items():
+        dependencies = KIT_DEPENDENCIES.get(product, [])
+        for dep in dependencies:
+            if dep in production_times:
+                dep_day = production_times[dep]
+                if dep_day > prod_day:  # Dependency produced after product
+                    violations += 1
+                    violation_details.append({
+                        'product': product,
+                        'dependency': dep,
+                        'production_day': prod_day,
+                        'dependency_day': dep_day,
+                        'severity': 'high' if dep_day - prod_day > 1 else 'medium',
+                        'impact': abs(dep_day - prod_day)
+                    })
+    
+    analytics['dependency_violations'] = violations
+    analytics['violations'] = violation_details
+    
+    return analytics
+
+# Removed calculate_hierarchy_line_utilization and create_utilization_gauge functions
+# - utilization concept removed from dashboard
+
+def create_hierarchy_heatmap(results):
+    """Create heatmap showing hierarchy production by line and day"""
+    # Prepare heatmap data
+    heatmap_data = []
+    
+    for row in results['run_schedule']:
+        product = row['product']
+        level_name = KitLevel.get_name(KIT_LEVELS.get(product, KitLevel.MASTER))
+        line_name = f"{LineType.get_name(row['line_type_id'])} {row['line_idx']}"
+        
+        heatmap_data.append({
+            'Line': line_name,
+            'Day': f"Day {row['day']}",
+            'Level': level_name,
+            'Units': row['units'],
+            'Hours': row['run_hours']
+        })
+    
+    if not heatmap_data:
+        return go.Figure()
+    
+    df = pd.DataFrame(heatmap_data)
+    
+    # Pivot for heatmap
+    pivot_df = df.pivot_table(
+        values='Units', 
+        index='Line', 
+        columns='Day', 
+        aggfunc='sum', 
+        fill_value=0
+    )
+    
+    fig = px.imshow(pivot_df.values, 
+                   x=pivot_df.columns, 
+                   y=pivot_df.index,
+                   color_continuous_scale='Blues',
+                   title='Production Volume Heatmap (Units per Day)',
+                   labels=dict(x="Day", y="Production Line", color="Units"))
+    
+    return fig
+
+def create_dependency_network_chart(analytics_data):
+    """Create network chart showing dependency relationships"""
+    dependencies = analytics_data.get('dependencies', {})
+    
+    if not dependencies or not NETWORKX_AVAILABLE:
+        return go.Figure().add_annotation(
+            text="Dependency network visualization requires 'networkx' package. Install with: pip install networkx" if not NETWORKX_AVAILABLE else "No dependency relationships to display",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False
+        )
+    
+    # Create network graph
+    G = nx.DiGraph()
+    
+    # Add nodes and edges
+    for product, deps in dependencies.items():
+        if product and deps:  # Only if product has dependencies
+            G.add_node(product)
+            for dep in deps:
+                if dep:  # Only if dependency exists
+                    G.add_node(dep)
+                    G.add_edge(dep, product)  # Dependency -> Product
+    
+    if len(G.nodes()) == 0:
+        return go.Figure().add_annotation(
+            text="No dependency relationships to display",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False
+        )
+    
+    # Calculate layout
+    pos = nx.spring_layout(G, k=3, iterations=50)
+    
+    # Create edge traces
+    edge_x = []
+    edge_y = []
+    for edge in G.edges():
+        x0, y0 = pos[edge[0]]
+        x1, y1 = pos[edge[1]]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+    
+    edge_trace = go.Scatter(x=edge_x, y=edge_y,
+                           line=dict(width=0.5, color='#888'),
+                           hoverinfo='none',
+                           mode='lines')
+    
+    # Create node traces
+    node_x = []
+    node_y = []
+    node_text = []
+    node_color = []
+    
+    for node in G.nodes():
+        x, y = pos[node]
+        node_x.append(x)
+        node_y.append(y)
+        node_text.append(node)
+        
+        # Color by hierarchy level
+        level = KIT_LEVELS.get(node, KitLevel.MASTER)
+        if level == KitLevel.PREPACK:
+            node_color.append('#90EE90')
+        elif level == KitLevel.SUBKIT:
+            node_color.append('#FFD700')
+        else:
+            node_color.append('#FF6347')
+    
+    node_trace = go.Scatter(x=node_x, y=node_y,
+                           mode='markers+text',
+                           text=node_text,
+                           textposition='middle center',
+                           marker=dict(size=20, color=node_color, line=dict(width=2, color='black')),
+                           hoverinfo='text',
+                           hovertext=node_text)
+    
+    fig = go.Figure(data=[edge_trace, node_trace],
+                   layout=go.Layout(
+                       title='Kit Dependency Network',
+                       titlefont_size=16,
+                       showlegend=False,
+                       hovermode='closest',
+                       margin=dict(b=20,l=5,r=5,t=40),
+                       annotations=[ dict(
+                           text="Green=Prepack, Gold=Subkit, Red=Master",
+                           showarrow=False,
+                           xref="paper", yref="paper",
+                           x=0.005, y=-0.002,
+                           xanchor='left', yanchor='bottom',
+                           font=dict(size=12)
+                       )],
+                       xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                       yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
+    
+    return fig
+
+
+
+
+
+def generate_sequence_suggestions(sequence_data):
+    """Generate optimization suggestions based on sequence analysis"""
+    suggestions = []
+    
+    adherence = sequence_data.get('sequence_adherence_score', 0)
+    violations = sequence_data.get('early_productions', 0)
+    
+    if adherence < 80:
+        suggestions.append(
+            "Consider adjusting production sequence to better follow hierarchy dependencies. "
+            "Current adherence is below optimal (80%)."
+        )
+    
+    if violations > 0:
+        suggestions.append(
+            f"Found {violations} dependency violations. Review production scheduling to ensure "
+            "prepacks are produced before subkits, and subkits before masters."
+        )
+    
+    if adherence >= 95:
+        suggestions.append(
+            "Excellent sequence adherence! Production is following optimal hierarchy flow."
+        )
+    
+    if not suggestions:
+        suggestions.append("Production sequence analysis complete. No major issues detected.")
+    
+    return suggestions
+
+def get_hierarchy_level_summary(flow_data):
+    """Get summary statistics for each hierarchy level"""
+    summary = {}
+    
+    for level_name in ['prepack', 'subkit', 'master']:
+        level_products = [row for row in flow_data if row['level_name'] == level_name]
+        
+        summary[level_name] = {
+            'count': len(set(row['product'] for row in level_products)),
+            'total_units': sum(row['units'] for row in level_products),
+            'total_hours': sum(row['hours'] for row in level_products)
+        }
+    
+    return summary

src/visualization/kit_relationships.py

@@ -0,0 +1,630 @@
+"""
+Kit Relationship Visualization
+Shows the actual dependency relationships between kits in production
+based on kit_hierarchy.json data
+"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import json
+import sys
+sys.path.append('src')
+
+from config.constants import ShiftType, LineType, KitLevel
+
+# Optional networkx for advanced network layouts
+try:
+    import networkx as nx
+    NETWORKX_AVAILABLE = True
+except ImportError:
+    NETWORKX_AVAILABLE = False
+    nx = None
+
+def load_kit_hierarchy():
+    """Load kit hierarchy data from JSON file"""
+    try:
+        with open('data/hierarchy_exports/kit_hierarchy.json', 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        st.error("Kit hierarchy file not found. Please ensure kit_hierarchy.json exists in data/hierarchy_exports/")
+        return {}
+    except json.JSONDecodeError:
+        st.error("Invalid kit hierarchy JSON format")
+        return {}
+
+def display_kit_relationships_dashboard(results):
+    """Main dashboard showing kit relationships in production"""
+    st.header("🔗 Kit Relationship Dashboard")
+    st.markdown("Visualizing dependencies between kits being produced")
+    st.markdown("---")
+    
+    # Load hierarchy data
+    hierarchy_data = load_kit_hierarchy()
+    
+    if not hierarchy_data:
+        st.warning("No kit hierarchy data available")
+        return
+    
+    # Get produced kits from results
+    produced_kits = set()
+    if 'weekly_production' in results:
+        produced_kits = set(results['weekly_production'].keys())
+    elif 'run_schedule' in results:
+        produced_kits = set(row['product'] for row in results['run_schedule'])
+    
+    if not produced_kits:
+        st.warning("No production data available")
+        return
+    
+    # Create tabs for different relationship views
+    tab1, tab2, tab3, tab4 = st.tabs([
+        "🌐 Dependency Network", 
+        "📊 Relationship Matrix",
+        "🎯 Production Flow",
+        "⚠️ Dependency Analysis"
+    ])
+    
+    with tab1:
+        display_dependency_network(hierarchy_data, produced_kits, results)
+    
+    with tab2:
+        display_relationship_matrix(hierarchy_data, produced_kits, results)
+    
+    with tab3:
+        display_production_flow_relationships(hierarchy_data, produced_kits, results)
+    
+    with tab4:
+        display_dependency_analysis(hierarchy_data, produced_kits, results)
+
+def display_dependency_network(hierarchy_data, produced_kits, results):
+    """Show interactive network graph of kit dependencies"""
+    st.subheader("🌐 Kit Dependency Network")
+    st.markdown("Interactive graph showing which kits depend on other kits")
+    
+    # Build relationship data for produced kits only
+    relationships = build_relationship_data(hierarchy_data, produced_kits)
+    
+    if not relationships:
+        st.info("No dependency relationships found between produced kits")
+        return
+    
+    # Get production timing data
+    production_timing = get_production_timing(results)
+    
+    # Create network visualization
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        if NETWORKX_AVAILABLE:
+            fig = create_interactive_network_graph(relationships, production_timing)
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            fig = create_simple_dependency_chart(relationships, production_timing)
+            st.plotly_chart(fig, use_container_width=True)
+            st.info("💡 Install networkx for advanced network layouts: `pip install networkx`")
+    
+    with col2:
+        # Network statistics
+        st.subheader("📈 Network Stats")
+        
+        all_kits = set()
+        for rel in relationships:
+            all_kits.add(rel['source'])
+            all_kits.add(rel['target'])
+        
+        st.metric("Total Kits", len(all_kits))
+        st.metric("Dependencies", len(relationships))
+        
+        # Dependency depth analysis
+        max_depth = calculate_dependency_depth(relationships)
+        st.metric("Max Dependency Depth", max_depth)
+        
+        # Most dependent kits
+        dependent_kits = get_most_dependent_kits(relationships)
+        st.subheader("🔗 Most Dependencies")
+        for kit, count in dependent_kits[:5]:
+            st.write(f"**{kit}**: {count} dependencies")
+
+def display_relationship_matrix(hierarchy_data, produced_kits, results):
+    """Show dependency matrix heatmap"""
+    st.subheader("📊 Kit Dependency Matrix")
+    st.markdown("Heatmap showing which kits (rows) depend on which other kits (columns)")
+    
+    # Build dependency matrix
+    matrix_data = build_dependency_matrix(hierarchy_data, produced_kits)
+    
+    if matrix_data.empty:
+        st.info("No dependency relationships to visualize in matrix form")
+        return
+    
+    # Create heatmap
+    fig = px.imshow(matrix_data.values,
+                   x=matrix_data.columns,
+                   y=matrix_data.index,
+                   color_continuous_scale='Blues',
+                   title='Kit Dependency Matrix (1 = depends on, 0 = no dependency)',
+                   labels=dict(x="Dependency (what is needed)", 
+                              y="Kit (what depends on others)", 
+                              color="Dependency"))
+    
+    fig.update_layout(height=600)
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Show matrix as table
+    with st.expander("📋 View Dependency Matrix as Table"):
+        st.dataframe(matrix_data, use_container_width=True)
+
+def display_production_flow_relationships(hierarchy_data, produced_kits, results):
+    """Show how relationships affect production timing"""
+    st.subheader("🎯 Production Flow with Relationships")
+    st.markdown("Timeline showing when dependent kits are produced")
+    
+    # Get production timing and relationships
+    production_timing = get_production_timing(results)
+    relationships = build_relationship_data(hierarchy_data, produced_kits)
+    
+    if not production_timing or not relationships:
+        st.info("Insufficient data for production flow analysis")
+        return
+    
+    # Create timeline with dependency arrows
+    fig = create_production_timeline_with_dependencies(production_timing, relationships)
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Timing analysis table
+    st.subheader("⏰ Dependency Timing Analysis")
+    timing_analysis = analyze_dependency_timing(production_timing, relationships)
+    
+    if timing_analysis:
+        df = pd.DataFrame(timing_analysis)
+        st.dataframe(df, use_container_width=True)
+
+def display_dependency_analysis(hierarchy_data, produced_kits, results):
+    """Analyze dependency fulfillment and violations"""
+    st.subheader("⚠️ Dependency Analysis & Violations")
+    
+    production_timing = get_production_timing(results)
+    relationships = build_relationship_data(hierarchy_data, produced_kits)
+    
+    # Analyze violations
+    violations = find_dependency_violations(production_timing, relationships)
+    
+    # Summary metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        total_deps = len(relationships)
+        st.metric("Total Dependencies", total_deps)
+    
+    with col2:
+        violated_deps = len(violations)
+        st.metric("Violations", violated_deps, 
+                 delta=f"-{violated_deps}" if violated_deps > 0 else None)
+    
+    with col3:
+        if total_deps > 0:
+            success_rate = ((total_deps - violated_deps) / total_deps) * 100
+            st.metric("Success Rate", f"{success_rate:.1f}%")
+        else:
+            st.metric("Success Rate", "N/A")
+    
+    with col4:
+        if violations:
+            avg_violation = sum(v['days_early'] for v in violations) / len(violations)
+            st.metric("Avg Days Early", f"{avg_violation:.1f}")
+        else:
+            st.metric("Avg Days Early", "0")
+    
+    # Violation details
+    if violations:
+        st.subheader("🚨 Dependency Violations")
+        st.markdown("Cases where kits were produced before their dependencies")
+        
+        violation_df = pd.DataFrame(violations)
+        
+        # Violation severity chart
+        fig = px.scatter(violation_df,
+                        x='dependency_day', y='kit_day',
+                        size='days_early', color='severity',
+                        hover_data=['kit', 'dependency'],
+                        title='Dependency Violations (Below diagonal = violation)',
+                        labels={'dependency_day': 'When Dependency Was Made',
+                               'kit_day': 'When Kit Was Made'})
+        
+        # Add diagonal line showing ideal timing
+        max_day = max(violation_df['dependency_day'].max(), violation_df['kit_day'].max())
+        fig.add_shape(type="line", x0=0, y0=0, x1=max_day, y1=max_day,
+                     line=dict(dash="dash", color="green"),
+                     name="Ideal Timeline")
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Detailed violation table
+        st.dataframe(violation_df[['kit', 'dependency', 'kit_day', 'dependency_day', 
+                                  'days_early', 'severity']], use_container_width=True)
+    else:
+        st.success("🎉 No dependency violations found! All kits produced in correct order.")
+    
+    # Recommendations
+    st.subheader("💡 Recommendations")
+    recommendations = generate_dependency_recommendations(violations, relationships, production_timing)
+    for rec in recommendations:
+        st.info(f"💡 {rec}")
+
+# Helper Functions
+
+def build_relationship_data(hierarchy_data, produced_kits):
+    """Build relationship data for visualization"""
+    relationships = []
+    
+    for kit_id, kit_info in hierarchy_data.items():
+        if kit_id not in produced_kits:
+            continue
+            
+        # Add direct dependencies
+        dependencies = kit_info.get('dependencies', [])
+        for dep in dependencies:
+            if dep in produced_kits:  # Only show relationships between produced kits
+                relationships.append({
+                    'source': dep,  # Dependency (what's needed)
+                    'target': kit_id,  # Kit that depends on it
+                    'type': 'direct',
+                    'source_type': hierarchy_data.get(dep, {}).get('type', 'unknown'),
+                    'target_type': kit_info.get('type', 'unknown')
+                })
+    
+    return relationships
+
+def build_dependency_matrix(hierarchy_data, produced_kits):
+    """Build dependency matrix for heatmap"""
+    produced_list = sorted(list(produced_kits))
+    
+    if len(produced_list) == 0:
+        return pd.DataFrame()
+    
+    # Initialize matrix
+    matrix = pd.DataFrame(0, index=produced_list, columns=produced_list)
+    
+    # Fill matrix with dependencies
+    for kit_id in produced_list:
+        kit_info = hierarchy_data.get(kit_id, {})
+        dependencies = kit_info.get('dependencies', [])
+        
+        for dep in dependencies:
+            if dep in produced_list:
+                matrix.loc[kit_id, dep] = 1  # kit_id depends on dep
+    
+    return matrix
+
+def get_production_timing(results):
+    """Extract production timing for each kit"""
+    timing = {}
+    
+    if 'run_schedule' in results:
+        for run in results['run_schedule']:
+            kit = run['product']
+            day = run['day']
+            
+            # Use earliest day if kit is produced multiple times
+            if kit not in timing or day < timing[kit]:
+                timing[kit] = day
+    
+    return timing
+
+def create_interactive_network_graph(relationships, production_timing):
+    """Create interactive network graph using NetworkX layout"""
+    if not NETWORKX_AVAILABLE:
+        return create_simple_dependency_chart(relationships, production_timing)
+    
+    # Create NetworkX graph
+    G = nx.DiGraph()
+    
+    # Add edges (relationships)
+    for rel in relationships:
+        G.add_edge(rel['source'], rel['target'], type=rel['type'])
+    
+    if len(G.nodes()) == 0:
+        return go.Figure().add_annotation(
+            text="No relationships to display",
+            xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+        )
+    
+    # Calculate layout
+    pos = nx.spring_layout(G, k=3, iterations=50)
+    
+    # Create edge traces
+    edge_x, edge_y = [], []
+    edge_info = []
+    
+    for edge in G.edges():
+        source, target = edge
+        x0, y0 = pos[source]
+        x1, y1 = pos[target]
+        
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+        
+        # Add arrow annotation
+        edge_info.append({
+            'x': (x0 + x1) / 2,
+            'y': (y0 + y1) / 2, 
+            'text': '→',
+            'source': source,
+            'target': target
+        })
+    
+    edge_trace = go.Scatter(x=edge_x, y=edge_y,
+                           line=dict(width=2, color='#888'),
+                           hoverinfo='none',
+                           mode='lines')
+    
+    # Create node traces
+    node_x, node_y, node_text, node_color, node_size = [], [], [], [], []
+    node_info = []
+    
+    for node in G.nodes():
+        x, y = pos[node]
+        node_x.append(x)
+        node_y.append(y)
+        
+        # Node size based on number of connections
+        in_degree = G.in_degree(node)
+        out_degree = G.out_degree(node)
+        total_degree = in_degree + out_degree
+        node_size.append(20 + total_degree * 5)
+        
+        # Color by production timing
+        prod_day = production_timing.get(node, 0)
+        if prod_day == 1:
+            node_color.append('#90EE90')  # Light green for early
+        elif prod_day <= 3:
+            node_color.append('#FFD700')  # Gold for middle
+        else:
+            node_color.append('#FF6347')  # Tomato for late
+        
+        # Node text and info
+        short_name = node[:12] + "..." if len(node) > 12 else node
+        node_text.append(short_name)
+        
+        node_info.append(f"{node}<br>Day: {prod_day}<br>In: {in_degree}, Out: {out_degree}")
+    
+    node_trace = go.Scatter(x=node_x, y=node_y,
+                           mode='markers+text',
+                           text=node_text,
+                           textposition='middle center',
+                           hovertext=node_info,
+                           hoverinfo='text',
+                           marker=dict(size=node_size, 
+                                     color=node_color,
+                                     line=dict(width=2, color='black')))
+    
+    # Create figure
+    fig = go.Figure(data=[edge_trace, node_trace],
+                   layout=go.Layout(
+                       title='Kit Dependency Network (Size=Connections, Color=Production Day)',
+                       showlegend=False,
+                       hovermode='closest',
+                       margin=dict(b=20,l=5,r=5,t=40),
+                       annotations=[
+                           dict(text="Green=Early, Gold=Middle, Red=Late production",
+                                showarrow=False,
+                                xref="paper", yref="paper",
+                                x=0.005, y=-0.002,
+                                xanchor='left', yanchor='bottom',
+                                font=dict(size=12))
+                       ],
+                       xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                       yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
+    
+    return fig
+
+def create_simple_dependency_chart(relationships, production_timing):
+    """Create simple dependency chart without NetworkX"""
+    if not relationships:
+        return go.Figure().add_annotation(
+            text="No dependencies to display", 
+            xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+        )
+    
+    # Create a simple directed graph visualization
+    # Group kits by their role (sources, targets)
+    sources = set(rel['source'] for rel in relationships)
+    targets = set(rel['target'] for rel in relationships)
+    
+    # Create positions
+    all_kits = list(sources | targets)
+    positions = {kit: (i, production_timing.get(kit, 0)) for i, kit in enumerate(all_kits)}
+    
+    # Create traces
+    edge_x, edge_y = [], []
+    for rel in relationships:
+        source_pos = positions[rel['source']]
+        target_pos = positions[rel['target']]
+        
+        edge_x.extend([source_pos[0], target_pos[0], None])
+        edge_y.extend([source_pos[1], target_pos[1], None])
+    
+    # Edge trace
+    edge_trace = go.Scatter(x=edge_x, y=edge_y,
+                           line=dict(width=2, color='#888'),
+                           hoverinfo='none',
+                           mode='lines')
+    
+    # Node trace
+    node_x = [positions[kit][0] for kit in all_kits]
+    node_y = [positions[kit][1] for kit in all_kits]
+    node_text = [kit[:10] + "..." if len(kit) > 10 else kit for kit in all_kits]
+    
+    node_trace = go.Scatter(x=node_x, y=node_y,
+                           mode='markers+text',
+                           text=node_text,
+                           textposition='top center',
+                           marker=dict(size=15, color='lightblue',
+                                     line=dict(width=2, color='black')),
+                           hovertext=all_kits,
+                           hoverinfo='text')
+    
+    fig = go.Figure(data=[edge_trace, node_trace],
+                   layout=go.Layout(
+                       title='Kit Dependencies (Y-axis = Production Day)',
+                       showlegend=False,
+                       xaxis=dict(title='Kits'),
+                       yaxis=dict(title='Production Day')))
+    
+    return fig
+
+def create_production_timeline_with_dependencies(production_timing, relationships):
+    """Create timeline showing production order with dependency arrows"""
+    if not production_timing:
+        return go.Figure()
+    
+    # Prepare data
+    timeline_data = []
+    for kit, day in production_timing.items():
+        timeline_data.append({
+            'Kit': kit,
+            'Day': day,
+            'Short_Name': kit[:15] + "..." if len(kit) > 15 else kit
+        })
+    
+    df = pd.DataFrame(timeline_data)
+    
+    # Create scatter plot
+    fig = px.scatter(df, x='Day', y='Kit', 
+                    hover_data=['Kit'],
+                    title='Production Timeline with Dependencies')
+    
+    # Add dependency arrows
+    for rel in relationships:
+        source_day = production_timing.get(rel['source'], 0)
+        target_day = production_timing.get(rel['target'], 0)
+        
+        # Add arrow if both kits are in timeline
+        if source_day > 0 and target_day > 0:
+            fig.add_annotation(
+                x=target_day, y=rel['target'],
+                ax=source_day, ay=rel['source'],
+                arrowhead=2, arrowsize=1, arrowwidth=2,
+                arrowcolor="red" if source_day > target_day else "green"
+            )
+    
+    fig.update_layout(height=max(400, len(df) * 20))
+    return fig
+
+def calculate_dependency_depth(relationships):
+    """Calculate maximum dependency depth"""
+    if not NETWORKX_AVAILABLE or not relationships:
+        return 0
+    
+    G = nx.DiGraph()
+    for rel in relationships:
+        G.add_edge(rel['source'], rel['target'])
+    
+    try:
+        return nx.dag_longest_path_length(G)
+    except:
+        return 0
+
+def get_most_dependent_kits(relationships):
+    """Get kits with most dependencies"""
+    dependency_counts = {}
+    
+    for rel in relationships:
+        target = rel['target']
+        dependency_counts[target] = dependency_counts.get(target, 0) + 1
+    
+    return sorted(dependency_counts.items(), key=lambda x: x[1], reverse=True)
+
+def find_dependency_violations(production_timing, relationships):
+    """Find cases where kits were produced before their dependencies"""
+    violations = []
+    
+    for rel in relationships:
+        source = rel['source']  # dependency
+        target = rel['target']  # kit that depends on it
+        
+        source_day = production_timing.get(source, 0)
+        target_day = production_timing.get(target, 0)
+        
+        if source_day > 0 and target_day > 0 and source_day > target_day:
+            days_early = source_day - target_day
+            severity = 'high' if days_early > 2 else 'medium' if days_early > 1 else 'low'
+            
+            violations.append({
+                'kit': target,
+                'dependency': source,
+                'kit_day': target_day,
+                'dependency_day': source_day,
+                'days_early': days_early,
+                'severity': severity
+            })
+    
+    return violations
+
+def analyze_dependency_timing(production_timing, relationships):
+    """Analyze timing of all dependency relationships"""
+    timing_analysis = []
+    
+    for rel in relationships:
+        source = rel['source']
+        target = rel['target']
+        
+        source_day = production_timing.get(source, 0)
+        target_day = production_timing.get(target, 0)
+        
+        if source_day > 0 and target_day > 0:
+            timing_diff = target_day - source_day
+            status = "✅ Correct" if timing_diff >= 0 else "❌ Violation"
+            
+            timing_analysis.append({
+                'Kit': target[:20] + "..." if len(target) > 20 else target,
+                'Dependency': source[:20] + "..." if len(source) > 20 else source,
+                'Kit Day': target_day,
+                'Dep Day': source_day,
+                'Gap (Days)': timing_diff,
+                'Status': status
+            })
+    
+    return sorted(timing_analysis, key=lambda x: x['Gap (Days)'])
+
+def generate_dependency_recommendations(violations, relationships, production_timing):
+    """Generate recommendations based on dependency analysis"""
+    recommendations = []
+    
+    if not violations:
+        recommendations.append("Excellent! All dependencies are being fulfilled in the correct order.")
+        return recommendations
+    
+    # Group violations by severity
+    high_severity = [v for v in violations if v['severity'] == 'high']
+    medium_severity = [v for v in violations if v['severity'] == 'medium']
+    
+    if high_severity:
+        recommendations.append(
+            f"🚨 High Priority: {len(high_severity)} critical dependency violations found. "
+            "Consider rescheduling production to ensure dependencies are produced first."
+        )
+    
+    if medium_severity:
+        recommendations.append(
+            f"⚠️ Medium Priority: {len(medium_severity)} moderate dependency timing issues. "
+            "Review production sequence for optimization opportunities."
+        )
+    
+    # Most problematic kits
+    problem_kits = {}
+    for v in violations:
+        kit = v['kit']
+        problem_kits[kit] = problem_kits.get(kit, 0) + 1
+    
+    if problem_kits:
+        worst_kit = max(problem_kits.items(), key=lambda x: x[1])
+        recommendations.append(
+            f"🎯 Focus Area: Kit {worst_kit[0]} has {worst_kit[1]} dependency issues. "
+            "Consider moving its production later in the schedule."
+        )
+    
+    return recommendations

test_hierarchy_viz.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Test script for hierarchy visualization
+Run this to see a demo of the hierarchy dashboard
+"""
+
+import sys
+import os
+sys.path.append('src')
+
+# Sample data for testing
+def create_sample_results():
+    """Create sample optimization results for testing"""
+    
+    # Sample schedule data showing hierarchy flow
+    sample_schedule = [
+        # Day 1: Prepacks first
+        {'day': 1, 'line_type_id': 6, 'line_idx': 1, 'shift': 1, 'product': 'PREPACK_A', 'run_hours': 4.0, 'units': 200},
+        {'day': 1, 'line_type_id': 7, 'line_idx': 1, 'shift': 1, 'product': 'PREPACK_B', 'run_hours': 3.5, 'units': 150},
+        
+        # Day 2: Subkits using prepacks
+        {'day': 2, 'line_type_id': 6, 'line_idx': 1, 'shift': 1, 'product': 'SUBKIT_X', 'run_hours': 5.0, 'units': 100},
+        {'day': 2, 'line_type_id': 7, 'line_idx': 2, 'shift': 2, 'product': 'SUBKIT_Y', 'run_hours': 4.5, 'units': 80},
+        
+        # Day 3: Master kits using subkits
+        {'day': 3, 'line_type_id': 6, 'line_idx': 2, 'shift': 1, 'product': 'MASTER_FINAL', 'run_hours': 6.0, 'units': 50},
+        {'day': 3, 'line_type_id': 7, 'line_idx': 1, 'shift': 3, 'product': 'MASTER_DELUXE', 'run_hours': 5.5, 'units': 40},
+    ]
+    
+    # Sample hierarchy data
+    sample_kit_levels = {
+        'PREPACK_A': 0,  # Prepack
+        'PREPACK_B': 0,  # Prepack
+        'SUBKIT_X': 1,   # Subkit
+        'SUBKIT_Y': 1,   # Subkit
+        'MASTER_FINAL': 2,   # Master
+        'MASTER_DELUXE': 2,  # Master
+    }
+    
+    # Sample dependencies
+    sample_dependencies = {
+        'SUBKIT_X': ['PREPACK_A'],
+        'SUBKIT_Y': ['PREPACK_B'],
+        'MASTER_FINAL': ['SUBKIT_X', 'PREPACK_A'],
+        'MASTER_DELUXE': ['SUBKIT_Y', 'PREPACK_B'],
+    }
+    
+    # Sample production totals
+    weekly_production = {
+        'PREPACK_A': 200,
+        'PREPACK_B': 150,
+        'SUBKIT_X': 100,
+        'SUBKIT_Y': 80,
+        'MASTER_FINAL': 50,
+        'MASTER_DELUXE': 40,
+    }
+    
+    # Sample workforce data
+    person_hours_by_day = [
+        {'day': 1, 'emp_type': 'UNICEF Fixed term', 'used_person_hours': 16, 'cap_person_hours': 64},
+        {'day': 1, 'emp_type': 'Humanizer', 'used_person_hours': 40, 'cap_person_hours': 80},
+        {'day': 2, 'emp_type': 'UNICEF Fixed term', 'used_person_hours': 20, 'cap_person_hours': 64},
+        {'day': 2, 'emp_type': 'Humanizer', 'used_person_hours': 45, 'cap_person_hours': 80},
+        {'day': 3, 'emp_type': 'UNICEF Fixed term', 'used_person_hours': 18, 'cap_person_hours': 64},
+        {'day': 3, 'emp_type': 'Humanizer', 'used_person_hours': 42, 'cap_person_hours': 80},
+    ]
+    
+    return {
+        'objective': 12500.75,  # Total cost
+        'run_schedule': sample_schedule,
+        'weekly_production': weekly_production,
+        'person_hours_by_day': person_hours_by_day,
+        'kit_levels': sample_kit_levels,
+        'kit_dependencies': sample_dependencies
+    }
+
+def test_hierarchy_flow():
+    """Test the hierarchy flow visualization components"""
+    print("🧪 Testing Hierarchy Visualization Components")
+    print("=" * 50)
+    
+    # Create sample data
+    results = create_sample_results()
+    print(f"✅ Created sample results with {len(results['run_schedule'])} production runs")
+    
+    try:
+        # Test imports
+        from src.visualization.hierarchy_dashboard import (
+            prepare_hierarchy_flow_data,
+            prepare_hierarchy_analytics_data,
+            calculate_hierarchy_line_utilization,
+            get_hierarchy_level_summary
+        )
+        print("✅ Successfully imported hierarchy dashboard functions")
+        
+        # Test flow data preparation
+        flow_data = prepare_hierarchy_flow_data(results)
+        print(f"✅ Prepared flow data: {len(flow_data)} flow records")
+        
+        # Test analytics data
+        analytics = prepare_hierarchy_analytics_data(results)
+        print(f"✅ Prepared analytics data: {analytics['dependency_violations']} violations detected")
+        
+        # Test line utilization calculation
+        line_util = calculate_hierarchy_line_utilization(results)
+        print(f"✅ Calculated line utilization for {len(line_util)} lines")
+        
+        # Test hierarchy summary
+        summary = get_hierarchy_level_summary(flow_data)
+        print("✅ Generated hierarchy level summary:")
+        for level, data in summary.items():
+            print(f"   - {level.title()}: {data['count']} products, {data['total_units']} units")
+        
+        print("\n🎉 All hierarchy visualization components working correctly!")
+        print("\nTo see the full visualization:")
+        print("1. Run your Streamlit app: streamlit run app.py")
+        print("2. Go to Settings page and run optimization")
+        print("3. Check the '🔄 Hierarchy Flow' tab in results")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error testing hierarchy visualization: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def display_sample_hierarchy_info():
+    """Display information about the sample hierarchy"""
+    print("\n📊 Sample Hierarchy Structure:")
+    print("=" * 30)
+    
+    print("🟢 PREPACKS (Level 0):")
+    print("   - PREPACK_A: Basic components")
+    print("   - PREPACK_B: Basic components")
+    
+    print("\n🟡 SUBKITS (Level 1):")
+    print("   - SUBKIT_X: Uses PREPACK_A")
+    print("   - SUBKIT_Y: Uses PREPACK_B")
+    
+    print("\n🔴 MASTERS (Level 2):")
+    print("   - MASTER_FINAL: Uses SUBKIT_X + PREPACK_A")
+    print("   - MASTER_DELUXE: Uses SUBKIT_Y + PREPACK_B")
+    
+    print("\n📅 Production Flow:")
+    print("   Day 1: Produce prepacks first (dependencies)")
+    print("   Day 2: Produce subkits (using prepacks)")  
+    print("   Day 3: Produce masters (using subkits)")
+    
+    print("\nThis demonstrates the optimal hierarchy flow!")
+
+if __name__ == "__main__":
+    print("🔄 Hierarchy Visualization Test")
+    print("=" * 40)
+    
+    # Display sample info
+    display_sample_hierarchy_info()
+    
+    # Test the components
+    success = test_hierarchy_flow()
+    
+    if success:
+        print(f"\n✅ Test completed successfully!")
+    else:
+        print(f"\n❌ Test failed - check error messages above")
+    
+    print("\n" + "=" * 40)

test_kit_relationships.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+Test script for kit relationships visualization
+Tests the actual kit dependency relationships from kit_hierarchy.json
+"""
+
+import sys
+import os
+sys.path.append('src')
+
+def test_kit_relationships():
+    """Test kit relationships visualization"""
+    print("🔗 Testing Kit Relationships Visualization")
+    print("=" * 50)
+    
+    try:
+        # Test importing the kit relationships module
+        from src.visualization.kit_relationships import (
+            load_kit_hierarchy,
+            build_relationship_data,
+            get_production_timing,
+            find_dependency_violations
+        )
+        print("✅ Successfully imported kit relationships module")
+        
+        # Test loading hierarchy data
+        hierarchy_data = load_kit_hierarchy()
+        if hierarchy_data:
+            print(f"✅ Loaded kit hierarchy: {len(hierarchy_data)} master kits")
+            
+            # Show some example relationships
+            print("\n📋 Sample Kit Relationships:")
+            count = 0
+            for kit_id, kit_info in hierarchy_data.items():
+                if kit_info.get('dependencies') and count < 5:
+                    deps = kit_info['dependencies']
+                    kit_name = kit_info.get('name', kit_id)[:50] + "..." if len(kit_info.get('name', '')) > 50 else kit_info.get('name', kit_id)
+                    print(f"  • {kit_id} ({kit_name})")
+                    print(f"    Depends on: {deps}")
+                    count += 1
+            
+            # Test with sample production data
+            sample_produced_kits = set(list(hierarchy_data.keys())[:10])  # First 10 kits
+            print(f"\n🧪 Testing with {len(sample_produced_kits)} sample produced kits")
+            
+            relationships = build_relationship_data(hierarchy_data, sample_produced_kits)
+            print(f"✅ Found {len(relationships)} dependency relationships")
+            
+            if relationships:
+                print("\n🔗 Sample Relationships:")
+                for i, rel in enumerate(relationships[:5]):
+                    print(f"  {i+1}. {rel['source']} → {rel['target']} ({rel['source_type']} → {rel['target_type']})")
+            
+            # Test production timing analysis
+            sample_timing = {kit: i % 5 + 1 for i, kit in enumerate(sample_produced_kits)}  # Random days 1-5
+            violations = find_dependency_violations(sample_timing, relationships)
+            print(f"✅ Dependency analysis: {len(violations)} violations found")
+            
+            print("\n🎉 Kit relationships visualization components working!")
+            return True
+            
+        else:
+            print("⚠️ No kit hierarchy data found - please check kit_hierarchy.json")
+            return False
+            
+    except FileNotFoundError:
+        print("❌ Kit hierarchy file not found at data/hierarchy_exports/kit_hierarchy.json")
+        return False
+    except Exception as e:
+        print(f"❌ Error testing kit relationships: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def display_hierarchy_structure():
+    """Display the structure of the hierarchy data"""
+    print("\n📊 Kit Hierarchy Structure Analysis")
+    print("=" * 40)
+    
+    try:
+        from src.visualization.kit_relationships import load_kit_hierarchy
+        hierarchy_data = load_kit_hierarchy()
+        
+        if not hierarchy_data:
+            print("No hierarchy data available")
+            return
+        
+        # Analyze hierarchy structure
+        masters = []
+        subkits = []
+        prepacks = []
+        
+        total_dependencies = 0
+        
+        for kit_id, kit_info in hierarchy_data.items():
+            kit_type = kit_info.get('type', 'unknown')
+            dependencies = kit_info.get('dependencies', [])
+            total_dependencies += len(dependencies)
+            
+            if kit_type == 'master':
+                masters.append(kit_id)
+            elif kit_type == 'subkit':
+                subkits.append(kit_id)
+            elif kit_type == 'prepack':
+                prepacks.append(kit_id)
+        
+        print(f"📦 Total Kits: {len(hierarchy_data)}")
+        print(f"  • Masters: {len(masters)}")
+        print(f"  • Subkits: {len(subkits)}")
+        print(f"  • Prepacks: {len(prepacks)}")
+        print(f"🔗 Total Dependencies: {total_dependencies}")
+        
+        # Find most complex kit (most dependencies)
+        max_deps = 0
+        most_complex = None
+        
+        for kit_id, kit_info in hierarchy_data.items():
+            deps = len(kit_info.get('dependencies', []))
+            if deps > max_deps:
+                max_deps = deps
+                most_complex = kit_id
+        
+        if most_complex:
+            print(f"🏆 Most Complex Kit: {most_complex} ({max_deps} dependencies)")
+        
+        # Show dependency chains
+        print(f"\n🔄 Sample Dependency Chains:")
+        chains_shown = 0
+        for kit_id, kit_info in hierarchy_data.items():
+            if kit_info.get('dependencies') and chains_shown < 3:
+                deps = kit_info['dependencies']
+                kit_name = kit_info.get('name', kit_id)[:40] + "..." if len(kit_info.get('name', '')) > 40 else kit_info.get('name', kit_id)
+                print(f"  Chain {chains_shown + 1}: {kit_name}")
+                for dep in deps[:3]:  # Show first 3 dependencies
+                    dep_info = hierarchy_data.get(dep, {})
+                    dep_name = dep_info.get('name', dep)[:30] + "..." if len(dep_info.get('name', '')) > 30 else dep_info.get('name', dep)
+                    print(f"    ↳ Needs: {dep_name}")
+                chains_shown += 1
+        
+        print(f"\nThis data will be visualized in the dashboard! 🎨")
+        
+    except Exception as e:
+        print(f"Error analyzing hierarchy: {e}")
+
+if __name__ == "__main__":
+    # Display hierarchy structure
+    display_hierarchy_structure()
+    
+    # Test kit relationships
+    success = test_kit_relationships()
+    
+    if success:
+        print(f"\n✅ Kit relationships test completed successfully!")
+        print(f"\nTo see the visualization:")
+        print(f"1. Run: streamlit run app.py")
+        print(f"2. Go to Settings → Run Optimization")  
+        print(f"3. Check 'Hierarchy Flow' → 'Kit Relationships' tab")
+        print(f"4. See the interactive network graph! 🕸️")
+    else:
+        print(f"\n❌ Test failed - check error messages above")
+    
+    print(f"\n" + "=" * 50)