Refactor optimization configuration and constants integration

- Updated `optimization_config.py` to utilize constants from `constants.py` for better maintainability.
- Added new constants for line counts, maximum parallel workers, and default rates.
- Enhanced session state initialization in `config_page.py` to use values from `DefaultConfig`.
- Improved architecture diagram to reflect changes in optimization flow.

ARCHITECTURE_DIAGRAM.md

@@ -486,7 +486,7 @@ sequenceDiagram
     Config->>OptConfig: Get all parameters
     OptConfig-->>Config: Return config
     
-    Config->>Optimizer: run_optimization_for_week()
+    Config->>Optimizer: Optimizer().run_optimization()
     
     Optimizer->>OptConfig: Get products
     Optimizer->>OptConfig: Get demand

src/config/constants.py

@@ -2,6 +2,7 @@
 Constants module for Supply Roster Optimization Tool
 Replaces hard-coded magic numbers with meaningful named constants
 """
+from src.preprocess import extract
 
 class ShiftType:
     """
@@ -138,6 +139,14 @@ class DefaultConfig:
     # Default minimum UNICEF fixed-term employees per day
     FIXED_MIN_UNICEF_PER_DAY = 2
     
+    # Default line counts
+    LINE_COUNT_LONG_LINE = 3
+    LINE_COUNT_MINI_LOAD = 2
+    
+    # Default max parallel workers per line (for UI)
+    MAX_PARALLEL_WORKERS_LONG_LINE = 7
+    MAX_PARALLEL_WORKERS_MINI_LOAD = 5
+    
     # Default cost rates (example values)
     DEFAULT_COST_RATES = {
         "UNICEF Fixed term": {
@@ -150,4 +159,44 @@ class DefaultConfig:
             ShiftType.EVENING: 27.94,
             ShiftType.OVERTIME: 41.91
         }
-    }
+    }
+    #get employee type list from data files
+    EMPLOYEE_TYPE_LIST =extract.read_employee_data()["employment_type"].unique().tolist()
+    SHIFT_LIST = extract.get_shift_info()["id"].unique().tolist()
+    EVENING_SHIFT_MODE = "normal"
+    EVENING_SHIFT_DEMAND_THRESHOLD = 0.9
+    
+    # Default schedule type
+    SCHEDULE_TYPE = "weekly"
+    
+    # Default fixed staff mode
+    FIXED_STAFF_MODE = "priority"
+    
+    # Default hourly rates for UI (simplified)
+    UNICEF_RATE_SHIFT_1 = 12.5
+    UNICEF_RATE_SHIFT_2 = 15.0
+    UNICEF_RATE_SHIFT_3 = 18.75
+    HUMANIZER_RATE_SHIFT_1 = 10.0
+    HUMANIZER_RATE_SHIFT_2 = 12.0
+    HUMANIZER_RATE_SHIFT_3 = 15.0
+    LINE_LIST = extract.read_packaging_line_data()["id"].unique().tolist()
+    LINE_CNT_PER_TYPE = extract.read_packaging_line_data().set_index("id")["line_count"].to_dict()
+    
+    # Dynamic method to get max employee per type on day
+    @staticmethod
+    def get_max_employee_per_type_on_day(date_span):
+        """Get max employee per type configuration for given date span"""
+        return {
+            "UNICEF Fixed term": {
+                t: 8 for t in date_span
+            },
+            "Humanizer": {
+                t: 10 for t in date_span
+            }
+        }
+    MAX_UNICEF_PER_DAY = 8
+    MAX_HUMANIZER_PER_DAY = 10
+    MAX_HOUR_PER_PERSON_PER_DAY = 14
+    KIT_LEVELS, KIT_DEPENDENCIES, PRODUCTION_PRIORITY_ORDER = extract.get_production_order_data()
+
+

src/config/optimization_config.py

@@ -91,6 +91,7 @@ EVENING_SHIFT_MODE = "normal"  # Default: only regular + overtime
 # If demand cannot be met with regular + overtime, suggest evening shift activation
 EVENING_SHIFT_DEMAND_THRESHOLD = 0.9  # Activate if regular+overtime capacity < 90% of demand
 
+#Where?
 def get_active_shift_list():
     """
     Get the list of active shifts based on EVENING_SHIFT_MODE setting.
@@ -122,7 +123,7 @@ def get_active_shift_list():
 # DO NOT load at import time - always call get_active_shift_list() dynamically
 # SHIFT_LIST = get_active_shift_list()  # REMOVED - was causing stale data!
 
-
+#where?
 def get_line_list():
     """Get line list - try from streamlit session state first, then from data files"""
     try:
@@ -143,7 +144,7 @@ def get_line_list():
 # DO NOT load at import time - always call get_line_list() dynamically
 # LINE_LIST = get_line_list()  # REMOVED - was causing stale data!
 
-
+#where?
 def get_kit_line_match():
     kit_line_match = extract.read_kit_line_match_data()
     kit_line_match_dict = kit_line_match.set_index("kit_name")["line_type"].to_dict()
@@ -200,6 +201,7 @@ def get_line_cnt_per_type():
 # DO NOT load at import time - always call get_line_cnt_per_type() dynamically
 # LINE_CNT_PER_TYPE = get_line_cnt_per_type()  # REMOVED - was causing stale data!
 
+#where?
 def get_demand_dictionary(force_reload=False):
     """
     Get filtered demand dictionary. 
@@ -224,6 +226,7 @@ def get_demand_dictionary(force_reload=False):
 # DO NOT load at import time - always call get_demand_dictionary() dynamically
 # DEMAND_DICTIONARY = get_demand_dictionary()  # REMOVED - was causing stale data!
 
+#delete as already using default cost rates
 def get_cost_list_per_emp_shift():
     try:
         # Try to get from streamlit session state (from config page)
@@ -260,7 +263,7 @@ def line_code_to_name():
 
 
 
-
+#where to put?
 def get_team_requirements(product_list=None):
     """
     Extract team requirements from Kits Calculation CSV.
@@ -310,58 +313,57 @@ def get_max_employee_per_type_on_day():
         print(f"Could not get max employee counts from streamlit session: {e}")
     
     print(f"Loading default max employee values")
+    # Get date span dynamically if not available
+    if DATE_SPAN is None:
+        date_span, _, _ = get_date_span()
+    else:
+        date_span = DATE_SPAN
+    
     max_employee_per_type_on_day = {
         "UNICEF Fixed term": {
-            t: 8 for t in DATE_SPAN
+            t: 8 for t in date_span
         },
         "Humanizer": {
-            t: 10 for t in DATE_SPAN
+            t: 10 for t in date_span
         }
     }
     return max_employee_per_type_on_day
 
 
-
+# Keep the constant for backward compatibility, but use function instead
 MAX_HOUR_PER_PERSON_PER_DAY = 14  # legal standard
 def get_max_hour_per_shift_per_person():
-    """Get max hours per shift per person - checks Streamlit session state first"""
+    """Get max hours per shift per person from session state or default"""
     try:
         import streamlit as st
-        if hasattr(st, 'session_state') and 'max_hour_per_shift_per_person' in st.session_state:
-            return st.session_state.max_hour_per_shift_per_person
+        if hasattr(st, 'session_state'):
+            # Build from individual session state values
+            max_hours = {
+                ShiftType.REGULAR: st.session_state.get('max_hours_shift_1', DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.REGULAR]),
+                ShiftType.EVENING: st.session_state.get('max_hours_shift_2', DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.EVENING]),
+                ShiftType.OVERTIME: st.session_state.get('max_hours_shift_3', DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.OVERTIME])
+            }
+            return max_hours
     except Exception as e:
         print(f"Could not get max hours per shift from session: {e}")
     
-    # Fallback to default only if not configured by user
+    # Fallback to default
     return DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON
 
 
 
 # Keep these complex getters that access DefaultConfig or have complex logic:
 def get_evening_shift_demand_threshold():
-    """Get evening shift demand threshold - checks Streamlit session state first"""
+    """Get evening shift demand threshold from session state or default"""
     try:
         import streamlit as st
-        if hasattr(st, 'session_state') and 'evening_shift_demand_threshold' in st.session_state:
-            return st.session_state.evening_shift_demand_threshold
+        if hasattr(st, 'session_state'):
+            return st.session_state.get('evening_shift_threshold', DefaultConfig.EVENING_SHIFT_DEMAND_THRESHOLD)
     except Exception as e:
         print(f"Could not get evening shift threshold from session: {e}")
     
-    # Fallback to default only if not configured by user
-    return getattr(DefaultConfig, 'EVENING_SHIFT_DEMAND_THRESHOLD', 10000)
-
-def get_fixed_min_unicef_per_day():
-    """Get fixed minimum UNICEF staff per day - checks Streamlit session state first"""
-    try:
-        import streamlit as st
-        if hasattr(st, 'session_state') and 'fixed_min_unicef_per_day' in st.session_state:
-            return st.session_state.fixed_min_unicef_per_day
-    except Exception as e:
-        print(f"Could not get fixed min UNICEF from session: {e}")
-    
-    # Fallback to default only if not configured by user
-    return getattr(DefaultConfig, 'FIXED_MIN_UNICEF_PER_DAY', {1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
-
+    # Fallback to default
+    return DefaultConfig.EVENING_SHIFT_DEMAND_THRESHOLD
 
 
 # ---- Kit Hierarchy for Production Ordering ----
@@ -383,22 +385,25 @@ def get_kit_dependencies():
     _, dependencies, _ = get_kit_hierarchy_data()
     return dependencies
 
-def get_production_priority_order():
-    """Get production priority order lazily - returns [kit_ids] sorted by production priority"""
-    _, _, priority_order = get_kit_hierarchy_data()
-    return priority_order
-
 def get_max_parallel_workers():
-    """Get max parallel workers - checks Streamlit session state first"""
+    """Get max parallel workers from session state or default"""
     try:
         import streamlit as st
-        if hasattr(st, 'session_state') and 'max_parallel_workers' in st.session_state:
-            return st.session_state.max_parallel_workers
+        if hasattr(st, 'session_state'):
+            # Build from individual session state values
+            max_parallel_workers = {
+                LineType.LONG_LINE: st.session_state.get('max_parallel_workers_long_line', DefaultConfig.MAX_PARALLEL_WORKERS_LONG_LINE),
+                LineType.MINI_LOAD: st.session_state.get('max_parallel_workers_mini_load', DefaultConfig.MAX_PARALLEL_WORKERS_MINI_LOAD)
+            }
+            return max_parallel_workers
     except Exception as e:
         print(f"Could not get max parallel workers from session: {e}")
     
-    # Fallback to default only if not configured by user
-    return DefaultConfig.MAX_PARALLEL_WORKERS
+    # Fallback to default
+    return {
+        LineType.LONG_LINE: DefaultConfig.MAX_PARALLEL_WORKERS_LONG_LINE,
+        LineType.MINI_LOAD: DefaultConfig.MAX_PARALLEL_WORKERS_MINI_LOAD
+    }
 
 
 

src/models/optimizer_real.py

@@ -9,718 +9,772 @@
 
 from ortools.linear_solver import pywraplp
 from math import ceil
+import datetime
 from src.config.constants import ShiftType, LineType, KitLevel
 
 # ---- config import ----
-from src.config.optimization_config import (
-    get_date_span,            # DYNAMIC: Get date span dynamically
-    get_product_list,         # DYNAMIC: list of products (e.g., ['A','B',...])
-    get_employee_type_list,   # DYNAMIC: e.g., ['UNICEF Fixed term','Humanizer']
-    get_active_shift_list,    # DYNAMIC: e.g., [1,2,3]
-    get_line_list,            # DYNAMIC: e.g., [6,7]  (line type ids)
-    get_line_cnt_per_type,    # DYNAMIC: {6: count_of_long_lines, 7: count_of_short_lines}
-    get_demand_dictionary,    # DYNAMIC: {product: total_units_over_period}
-    get_cost_list_per_emp_shift,  # DYNAMIC: {emp_type: {shift: cost_per_hour}}
-    get_max_employee_per_type_on_day,    # DYNAMIC: {emp_type: {t: headcount}}
-    MAX_HOUR_PER_PERSON_PER_DAY,     # e.g., 14
-    get_max_hour_per_shift_per_person,   # DYNAMIC: {1: hours, 2: hours, 3: hours}
-    get_max_parallel_workers,        # DYNAMIC: {6: max_workers, 7: max_workers}
-    get_team_requirements,    # DYNAMIC: {emp_type: {product: team_size}} from Kits_Calculation.csv
-    get_payment_mode_config,         # DYNAMIC: {shift: 'bulk'/'partial'} payment mode configuration
-    get_kit_line_match,              # DYNAMIC: Get kit line match lazily
-    EVENING_SHIFT_MODE,
-    EVENING_SHIFT_DEMAND_THRESHOLD,
-    # Hierarchy variables for production ordering
-    get_kit_levels,                  # DYNAMIC: {kit_id: level} where 0=prepack, 1=subkit, 2=master
-    get_kit_dependencies,            # DYNAMIC: {kit_id: [dependency_list]}
-    get_production_priority_order,   # DYNAMIC: [kit_ids] sorted by production priority
-    # Fixed staffing requirements
-    get_fixed_min_unicef_per_day,    # DYNAMIC: Minimum UNICEF employees required per day
-)
-
-
-
-# 2) kit_line_match - no printing to avoid spam
-# KIT_LINE_MATCH_DICT loaded lazily in functions that need it
-
-# 3) If specific product is not produced on specific date, set it to 0
-# ACTIVE will be built dynamically in solve function based on fresh PRODUCT_LIST
-# Example: ACTIVE[2]['C'] = 0  # Disable product C on day 2
-
-
-def build_lines():
-    """List of line instances.
-       line_tuples elements are (line_type_id, idx) tuples. e.g., (6,1), (6,2), (7,1), ...
-    """
-    line_tuples = []
-    LINE_LIST = get_line_list()  # Dynamic call
-    LINE_CNT_PER_TYPE = get_line_cnt_per_type()  # Dynamic call
-    
-    for lt in LINE_LIST:  # lt: 6 or 7
-        cnt = int(LINE_CNT_PER_TYPE.get(lt, 0))
-        for i in range(1, cnt + 1):
-            line_tuples.append((lt, i))
-    return line_tuples
-
-# DISABLED: Module-level initialization was causing infinite loops
-# These variables are now created dynamically when needed
-# line_tuples=build_lines()
-# print("line_tuples",line_tuples)
-# PER_PRODUCT_SPEED = extract.read_package_speed_data()  # Dynamic call
-# print("PER_PRODUCT_SPEED",PER_PRODUCT_SPEED)
-
-def sort_products_by_hierarchy(product_list):
-    """
-    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]
-    
-    if products_without_hierarchy:
-        print(f"[HIERARCHY] Products without hierarchy data: {products_without_hierarchy}")
-    
-    # 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
-    # KIT_DEPENDENCIES = {product: [dependencies]} - "What does THIS product need?"
-    # graph = {dependency: [products]} - "What depends on THIS dependency?"
-    # 
-    # Example transformation:
-    # KIT_DEPENDENCIES = {'subkit_A': ['prepack_1'], 'master_B': ['subkit_A']}
-    # After building: graph = {'prepack_1': ['subkit_A'], 'subkit_A': ['master_B']}
-    # This means: prepack_1 is needed by subkit_A, subkit_A is needed by master_B
-    #
-    # Example:
-    # 1. product='subkit_A', deps=['prepack_1']
-    #    → graph['prepack_1'].append('subkit_A')
-    #    → graph = {'prepack_1': ['subkit_A']}
-    # 2. product='master_B', deps=['subkit_A'] 
-    #    → graph['subkit_A'].append('master_B')
-    #    → graph = {'prepack_1': ['subkit_A'], 'subkit_A': ['master_B']}
-    
-    
-    for product in products_with_hierarchy:
-        deps = KIT_DEPENDENCIES.get(product, []) #dependencies = products that has to be packed first
-        for dep in deps:
-            if dep in products_with_hierarchy:  # Only if dependency is in our production list
-                # REVERSE THE RELATIONSHIP: 
-                # KIT_DEPENDENCIES says: "product needs dep"
-                # graph says: "dep is needed by product"
-                graph[dep].append(product)  # dep -> product (reverse the relationship!)
-                in_degree[product] += 1
-    
-    # Topological sort with hierarchy level priority
-    sorted_products = []
-    #queue = able to remove from both sides
-    queue = deque()
-    
-    # Start with products that have no dependencies
-    for product in products_with_hierarchy:
-        if in_degree[product] == 0:
-            queue.append(product)
-    
-    while queue:
-        current = queue.popleft()
-        sorted_products.append(current)
-        
-        # Process dependents - sort by hierarchy level first
-        for dependent in sorted(graph[current], key=lambda p: (KIT_LEVELS.get(p, 999), p)):
-            in_degree[dependent] -= 1 #decrement the in_degree of the dependent
-            if in_degree[dependent] == 0: #if the in_degree of the dependent is 0, add it to the queue so that it can be processed
-                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 information at the end
-    sorted_products.extend(sorted(products_without_hierarchy))
-    
-    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, [])
-        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
-
-# Removed get_dependency_timing_weight function - no longer needed
-# Dependency ordering is now handled by topological sorting in sort_products_by_hierarchy()
-
-def run_optimization_for_week():
-    # Load hierarchy data lazily at the start of optimization
-    global KIT_LEVELS, KIT_DEPENDENCIES, PRODUCTION_PRIORITY_ORDER, KIT_LINE_MATCH_DICT
-    KIT_LEVELS = get_kit_levels()
-    KIT_DEPENDENCIES = get_kit_dependencies()
-    PRODUCTION_PRIORITY_ORDER = get_production_priority_order()
-    KIT_LINE_MATCH_DICT = get_kit_line_match()
-    
-    # *** CRITICAL: Load fresh data to reflect current Streamlit configs ***
-    print("\n" + "="*60)
-    print("🔄 LOADING FRESH DATA FOR OPTIMIZATION")
-    print("="*60)
-    
-    # Get fresh product list and demand data
-    PRODUCT_LIST = get_product_list()
-    DEMAND_DICTIONARY = get_demand_dictionary()
-    TEAM_REQ_PER_PRODUCT = get_team_requirements(PRODUCT_LIST)
-    
-    # Get date span dynamically
-    DATE_SPAN, start_date, end_date = get_date_span()
-    
-    print(f"📦 LOADED PRODUCTS: {len(PRODUCT_LIST)} products")
-    print(f"📈 LOADED DEMAND: {sum(DEMAND_DICTIONARY.values())} total units")
-    print(f"👥 LOADED TEAM REQUIREMENTS: {len(TEAM_REQ_PER_PRODUCT)} employee types")
-    
-    # Build ACTIVE schedule for fresh product list
-    ACTIVE = {t: {p: 1 for p in PRODUCT_LIST} for t in DATE_SPAN}
-    
-    # --- Sets ---
-    date_span_list = list(DATE_SPAN)
-    # print("date_span_list",date_span_list)
-    active_shift_list = sorted(list(get_active_shift_list()))  # Dynamic call
-    employee_type_list = list(get_employee_type_list())  # Dynamic call - e.g., ['UNICEF Fixed term','Humanizer']
-    print("employee_type_list",employee_type_list)
-    # *** HIERARCHY SORTING: Sort products by production priority ***
-    print("\n" + "="*60)
-    print("🔗 APPLYING HIERARCHY-BASED PRODUCTION ORDERING")
-    print("="*60)
-    sorted_product_list = sort_products_by_hierarchy(list(PRODUCT_LIST))
-    
-    line_tuples = build_lines()
-    print("Lines",line_tuples)
-    
-    # Load product speed data dynamically
-    # Import extract module for direct access to data functions
-    from src.preprocess import extract
-    PER_PRODUCT_SPEED = extract.read_package_speed_data()
-    print("PER_PRODUCT_SPEED",PER_PRODUCT_SPEED)
-
-    # --- Short aliases for parameters ---
-    Hmax_s = dict(get_max_hour_per_shift_per_person())  # Dynamic call - per-shift hours
-    Hmax_daily = MAX_HOUR_PER_PERSON_PER_DAY          # {6:cap, 7:cap}
-    max_workers_line = dict(get_max_parallel_workers())  # Dynamic call - per line type
-    max_employee_type_day = get_max_employee_per_type_on_day()        # Dynamic call - {emp_type:{t:headcount}}
-    cost = get_cost_list_per_emp_shift()              # Dynamic call - {emp_type:{shift:cost}}
-    # --- Feasibility quick checks ---
-    
-    # 1) If team size is greater than max_workers_line, block the product-line type combination
-    for p in sorted_product_list:
-        req_total = sum(TEAM_REQ_PER_PRODUCT[e][p] for e in employee_type_list)
-        lt = KIT_LINE_MATCH_DICT.get(p, 6)  # Default to long line (6) if not found
-        if p not in KIT_LINE_MATCH_DICT:
-            print(f"[WARN] Product {p}: No line type mapping found, defaulting to long line (6)")
-        if req_total > max_workers_line.get(lt, 1e9):
-            print(f"[WARN] Product {p}: team size {req_total} > MAX_PARALLEL_WORKERS[{lt}] "
-                  f"= {max_workers_line.get(lt)}. Blocked.")
-
-    # 2) Check if demand can be met without evening shift (only if in normal mode)
-    if EVENING_SHIFT_MODE == "normal":
-        total_demand = sum(DEMAND_DICTIONARY.get(p, 0) for p in sorted_product_list)
-        
-        # Calculate maximum capacity with regular + overtime shifts only
-        regular_overtime_shifts = [s for s in active_shift_list if s in ShiftType.REGULAR_AND_OVERTIME]
-        max_capacity = 0
+# Import constants and other modules directly
+from src.config.constants import ShiftType, LineType, DefaultConfig
+import src.preprocess.extract as extract
+from src.preprocess.hierarchy_parser import sort_products_by_hierarchy
+
+class Optimizer:
+    """Workforce optimization class that handles all configuration and optimization logic"""
+    
+    def __init__(self):
+        """Initialize optimizer with session state configuration"""
+        self.load_session_state_config()
+        self.load_data()
+    
+    def load_session_state_config(self):
+        """Load all configuration from session state"""
+        import streamlit as st
+        import datetime as dt
         
-        for p in sorted_product_list:
-            if p in PER_PRODUCT_SPEED:
-                product_speed = PER_PRODUCT_SPEED[p]  # units per hour
-                # Calculate max hours available for this product across all lines and shifts
-                max_hours_per_product = 0
-                for ell in line_tuples:
-                    for s in regular_overtime_shifts:
-                        for t in date_span_list:
-                            max_hours_per_product += Hmax_s[s]
+        # Date configuration
+        self.start_date = st.session_state.start_date
+        self.planning_days = st.session_state.planning_days
+        self.start_datetime = dt.datetime.combine(self.start_date, dt.datetime.min.time())
+        self.end_date = self.start_datetime + dt.timedelta(days=self.planning_days - 1)
+        self.date_span = list(range(1, self.planning_days + 1))
+        
+        # Employee and shift configuration
+        self.employee_type_list = list(st.session_state.selected_employee_types)
+        self.active_shift_list = sorted(list(st.session_state.selected_shifts))
+        
+        print("\n[DEBUG] From session_state.selected_employee_types:")
+        for emp in self.employee_type_list:
+            print(f"  - '{emp}' (len={len(emp)}, repr={repr(emp)})")
+        
+        # Working hours configuration
+        self.max_hour_per_person_per_day = st.session_state.max_hour_per_person_per_day
+        self.max_hours_shift = {
+            ShiftType.REGULAR: st.session_state.max_hours_shift_1,
+            ShiftType.EVENING: st.session_state.max_hours_shift_2,
+            ShiftType.OVERTIME: st.session_state.max_hours_shift_3
+        }
+        
+        # Workforce limits
+        self.max_employee_per_type_on_day = st.session_state.max_employee_per_type_on_day
+        
+        # Operations configuration
+        self.line_counts = st.session_state.line_counts
+        self.max_parallel_workers = {
+            LineType.LONG_LINE: st.session_state.max_parallel_workers_long_line,
+            LineType.MINI_LOAD: st.session_state.max_parallel_workers_mini_load
+        }
+        
+        # Cost configuration
+        self.cost_list_per_emp_shift = st.session_state.cost_list_per_emp_shift
+        
+        # Payment mode configuration
+        self.payment_mode_config = st.session_state.payment_mode_config
+        
+        # Fixed staffing requirements
+        self.fixed_min_unicef_per_day = st.session_state.fixed_min_unicef_per_day
+        
+        print("✅ Session state configuration loaded successfully")
+    
+    def load_data(self):
+        """Load all required data from files"""
+        # Load hierarchy data
+        try:
+            kit_levels, dependencies, priority_order = extract.get_production_order_data()
+            self.kit_levels = kit_levels
+            self.kit_dependencies = dependencies
+            self.production_priority_order = priority_order
+        except:
+            self.kit_levels = {}
+            self.kit_dependencies = {}
+            self.production_priority_order = []
+        
+        # Load kit line match data
+        try:
+            kit_line_match = extract.read_kit_line_match_data()
+            kit_line_match_dict = kit_line_match.set_index("kit_name")["line_type"].to_dict()
+            
+            # Create line name to ID mapping
+            line_name_to_id = {
+                "long line": LineType.LONG_LINE,
+                "mini load": LineType.MINI_LOAD
+            }
+            
+            # Convert line names to IDs
+            self.kit_line_match_dict = {}
+            for kit_name, line_name in kit_line_match_dict.items():
+                self.kit_line_match_dict[kit_name] = line_name_to_id.get(line_name.lower(), line_name)
+        except:
+            self.kit_line_match_dict = {}
+        
+        # Load product and demand data
+        try:
+            from src.demand_filtering import DemandFilter
+            filter_instance = DemandFilter()
+            filter_instance.load_data(force_reload=True)
+            self.product_list = filter_instance.get_filtered_product_list()
+            self.demand_dictionary = filter_instance.get_filtered_demand_dictionary()
+        except:
+            self.product_list = []
+            self.demand_dictionary = {}
+        
+        # Load team requirements
+        try:
+            print("\n[DEBUG] Loading team requirements from Kits Calculation...")
+            kits_df = extract.read_personnel_requirement_data()
+            print(f"[DEBUG] Loaded kits_df with {len(kits_df)} rows")
+            print(f"[DEBUG] Columns: {list(kits_df.columns)}")
+            
+            # Initialize team requirements dictionary
+            self.team_req_per_product = {
+                "UNICEF Fixed term": {},
+                "Humanizer": {}
+            }
+            
+            # Process each product in the product list
+            for product in self.product_list:
+                product_data = kits_df[kits_df['Kit'] == product]
+                if not product_data.empty:
+                    # Extract Humanizer and UNICEF staff requirements
+                    humanizer_req = product_data["Humanizer"].iloc[0]
+                    unicef_req = product_data["UNICEF staff"].iloc[0]
+                    
+                    # Convert to int (data is already cleaned in extract function)
+                    self.team_req_per_product["Humanizer"][product] = int(humanizer_req)
+                    self.team_req_per_product["UNICEF Fixed term"][product] = int(unicef_req)
+                else:
+                    print(f"[WARN] Product {product} not found in Kits Calculation, setting requirements to 0")
+                    self.team_req_per_product["Humanizer"][product] = 0
+                    self.team_req_per_product["UNICEF Fixed term"][product] = 0
+            
+            print(f"\n[DEBUG] team_req_per_product keys after loading:")
+            for key in self.team_req_per_product.keys():
+                product_count = len(self.team_req_per_product[key])
+                print(f"  - '{key}' (len={len(key)}, {product_count} products)")
                 
-                max_capacity += product_speed * max_hours_per_product
+        except Exception as e:
+            print(f"[ERROR] Failed to load team requirements: {e}")
+            import traceback
+            traceback.print_exc()
+            self.team_req_per_product = {}
         
-        capacity_ratio = max_capacity / total_demand if total_demand > 0 else float('inf')
+        # Load product speed data
+        try:
+            self.per_product_speed = extract.read_package_speed_data()
+        except:
+            self.per_product_speed = {}
         
-        print(f"[CAPACITY CHECK] Total demand: {total_demand}")
-        print(f"[CAPACITY CHECK] Max capacity (Regular + Overtime): {max_capacity:.1f}")
-        print(f"[CAPACITY CHECK] Capacity ratio: {capacity_ratio:.2f}")
+        print("✅ All data loaded successfully")
+    
+    def build_lines(self):
+        """Build line instances from session state configuration"""
+        line_tuples = []
         
-        if capacity_ratio < EVENING_SHIFT_DEMAND_THRESHOLD:
-            print(f"\n🚨 [ALERT] DEMAND TOO HIGH!")
-            print(f"   Current capacity can only meet {capacity_ratio*100:.1f}% of demand")
-            print(f"   Threshold: {EVENING_SHIFT_DEMAND_THRESHOLD*100:.1f}%")
-            print(f"   RECOMMENDATION: Change EVENING_SHIFT_MODE to 'activate_evening' to enable evening shift")
-            print(f"   This will add shift 3 to increase capacity\n")
+        try:
+            import streamlit as st
+            # Get selected line types from Data Selection tab
+            selected_lines = st.session_state.selected_lines
+            # Get line counts from Operations tab  
+            line_counts = st.session_state.line_counts
+            
+            print(f"Using lines from session state - selected: {selected_lines}, counts: {line_counts}")
+            for line_type in selected_lines:
+                count = line_counts.get(line_type, 0)
+                for i in range(1, count + 1):
+                    line_tuples.append((line_type, i))
+            
+            return line_tuples
+        
+        except Exception as e:
+            print(f"Could not get line config from session state: {e}")
+            # Fallback: Use default values
+            print("Falling back to default line configuration")
+            default_selected_lines = [LineType.LONG_LINE, LineType.MINI_LOAD]
+            default_line_counts = {
+                LineType.LONG_LINE: DefaultConfig.LINE_COUNT_LONG_LINE,
+                LineType.MINI_LOAD: DefaultConfig.LINE_COUNT_MINI_LOAD
+            }
+            
+            for line_type in default_selected_lines:
+                count = default_line_counts.get(line_type, 0)
+                for i in range(1, count + 1):
+                    line_tuples.append((line_type, i))
+            
+            return line_tuples
+
+    def run_optimization(self):
+        """Run the main optimization algorithm"""
+        # *** CRITICAL: Load fresh data to reflect current Streamlit configs ***
+        print("\n" + "="*60)
+        print("🔄 LOADING FRESH DATA FOR OPTIMIZATION")
+        print("="*60)
+        
+        print(f"📦 LOADED PRODUCTS: {len(self.product_list)} products")
+        print(f"📈 LOADED DEMAND: {sum(self.demand_dictionary.values())} total units")
+        print(f"👥 LOADED TEAM REQUIREMENTS: {len(self.team_req_per_product)} employee types")
+        
+        # Debug: Print team requirements keys
+        print("\n[DEBUG] team_req_per_product employee types:")
+        for emp_type in self.team_req_per_product.keys():
+            print(f"  - '{emp_type}'")
+        
+        print("\n[DEBUG] self.employee_type_list:")
+        for emp_type in self.employee_type_list:
+            print(f"  - '{emp_type}'")
+        
+        # Build ACTIVE schedule for fresh product list
+        ACTIVE = {t: {p: 1 for p in self.product_list} for t in self.date_span}
+        
+        # --- Sets ---
+        date_span_list = list(self.date_span)
+        employee_type_list = self.employee_type_list
+        active_shift_list = self.active_shift_list
+        print(f"\n[DEBUG] employee_type_list: {employee_type_list}")
+        print(f"[DEBUG] active_shift_list: {active_shift_list}")
+        
+        # *** HIERARCHY SORTING: Sort products by production priority ***
+        print("\n" + "="*60)
+        print("🔗 APPLYING HIERARCHY-BASED PRODUCTION ORDERING")
+        print("="*60)
+        sorted_product_list = sort_products_by_hierarchy(list(self.product_list), self.kit_levels, self.kit_dependencies)
+        
+        line_tuples = self.build_lines()
+        print("Lines", line_tuples)
+        
+        print("PER_PRODUCT_SPEED", self.per_product_speed)
+
+        # --- Short aliases for parameters ---
+        print("\n[DEBUG] Creating variable aliases...")
+        Hmax_s = dict(self.max_hours_shift)  # per-shift hours
+        Hmax_daily = self.max_hour_per_person_per_day
+        max_workers_line = dict(self.max_parallel_workers)  # per line type
+        max_employee_type_day = self.max_employee_per_type_on_day  # {emp_type:{t:headcount}}
+        cost = self.cost_list_per_emp_shift  # {emp_type:{shift:cost}}
+        
+        # Create aliases for data dictionaries
+        TEAM_REQ_PER_PRODUCT = self.team_req_per_product
+        DEMAND_DICTIONARY = self.demand_dictionary
+        KIT_LINE_MATCH_DICT = self.kit_line_match_dict
+        KIT_LEVELS = self.kit_levels
+        KIT_DEPENDENCIES = self.kit_dependencies
+        PER_PRODUCT_SPEED = self.per_product_speed
+        FIXED_MIN_UNICEF_PER_DAY = self.fixed_min_unicef_per_day
+        PAYMENT_MODE_CONFIG = self.payment_mode_config
+        
+        # Mock missing config variables (if they exist in config, they'll be overridden)
+        EVENING_SHIFT_MODE = "normal"
+        EVENING_SHIFT_DEMAND_THRESHOLD = 0.9
+        
+        print(f"[DEBUG] TEAM_REQ_PER_PRODUCT has {len(TEAM_REQ_PER_PRODUCT)} employee types")
+        print(f"[DEBUG] employee_type_list has {len(employee_type_list)} types")
+        
+        # --- Feasibility quick checks ---
+        print("\n[DEBUG] Starting feasibility checks...")
+    
+        # 1) If team size is greater than max_workers_line, block the product-line type combination
+        for i, p in enumerate(sorted_product_list):
+            print(f"[DEBUG] Checking product {i+1}/{len(sorted_product_list)}: {p}")
+            
+            # Check if all employee types exist in TEAM_REQ_PER_PRODUCT
+            for e in employee_type_list:
+                if e not in TEAM_REQ_PER_PRODUCT:
+                    print(f"[ERROR] Employee type '{e}' not found in TEAM_REQ_PER_PRODUCT!")
+                    print(f"[ERROR] Available keys: {list(TEAM_REQ_PER_PRODUCT.keys())}")
+                    raise KeyError(f"Employee type '{e}' not in team requirements data")
+                if p not in TEAM_REQ_PER_PRODUCT[e]:
+                    print(f"[ERROR] Product '{p}' not found in TEAM_REQ_PER_PRODUCT['{e}']!")
+                    raise KeyError(f"Product '{p}' not in team requirements for employee type '{e}'")
+            
+            req_total = sum(TEAM_REQ_PER_PRODUCT[e][p] for e in employee_type_list)
+            print(f"[DEBUG]   req_total: {req_total}")
+            lt = KIT_LINE_MATCH_DICT.get(p, 6)  # Default to long line (6) if not found
+            if p not in KIT_LINE_MATCH_DICT:
+                print(f"[WARN] Product {p}: No line type mapping found, defaulting to long line (6)")
+            if req_total > max_workers_line.get(lt, 1e9):
+                print(f"[WARN] Product {p}: team size {req_total} > MAX_PARALLEL_WORKERS[{lt}] "
+                      f"= {max_workers_line.get(lt)}. Blocked.")
+
+        # 2) Check if demand can be met without evening shift (only if in normal mode)
+        if EVENING_SHIFT_MODE == "normal":
+            total_demand = sum(DEMAND_DICTIONARY.get(p, 0) for p in sorted_product_list)
+            
+            # Calculate maximum capacity with regular + overtime shifts only
+            regular_overtime_shifts = [s for s in active_shift_list if s in ShiftType.REGULAR_AND_OVERTIME]
+            max_capacity = 0
+            
+            for p in sorted_product_list:
+                if p in PER_PRODUCT_SPEED:
+                    product_speed = PER_PRODUCT_SPEED[p]  # units per hour
+                    # Calculate max hours available for this product across all lines and shifts
+                    max_hours_per_product = 0
+                    for ell in line_tuples:
+                        for s in regular_overtime_shifts:
+                            for t in date_span_list:
+                                max_hours_per_product += Hmax_s[s]
+                    
+                    max_capacity += product_speed * max_hours_per_product
+            
+            capacity_ratio = max_capacity / total_demand if total_demand > 0 else float('inf')
+            
+            print(f"[CAPACITY CHECK] Total demand: {total_demand}")
+            print(f"[CAPACITY CHECK] Max capacity (Regular + Overtime): {max_capacity:.1f}")
+            print(f"[CAPACITY CHECK] Capacity ratio: {capacity_ratio:.2f}")
+            
+            if capacity_ratio < EVENING_SHIFT_DEMAND_THRESHOLD:
+                print(f"\n🚨 [ALERT] DEMAND TOO HIGH!")
+                print(f"   Current capacity can only meet {capacity_ratio*100:.1f}% of demand")
+                print(f"   Threshold: {EVENING_SHIFT_DEMAND_THRESHOLD*100:.1f}%")
+                print(f"   RECOMMENDATION: Change EVENING_SHIFT_MODE to 'activate_evening' to enable evening shift")
+                print(f"   This will add shift 3 to increase capacity\n")
+
+
+        # --- Solver ---
+        solver = pywraplp.Solver.CreateSolver('CBC')
+        if not solver:
+            raise RuntimeError("CBC solver not found.")
+        INF = solver.infinity()
+
+        # --- Variables ---
+        # Assignment[p,ell,s,t] ∈ {0,1}: 1 if product p runs on (line,shift,day)
+        Assignment, Hours, Units = {}, {}, {}  # Hours: run hours, Units: production units
+        for p in sorted_product_list:
+            for ell in line_tuples:     # ell = (line_type_id, idx)
+                for s in active_shift_list:
+                    for t in date_span_list:
+                        #Is product p assigned to run on line ell, during shift s, on day t?
+                        Assignment[p, ell, s, t] = solver.BoolVar(f"Z_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
+                        #How many hours does product p run on line ell, during shift s, on day t?
+                        Hours[p, ell, s, t] = solver.NumVar(0, Hmax_s[s], f"T_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
+                        #How many units does product p run on line ell, during shift s, on day t?
+                        Units[p, ell, s, t] = solver.NumVar(0, INF,       f"U_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
+        
+        # Note: IDLE variables removed - we only track employees actually working on production
+        
+        # Variable to track actual number of employees of each type working each shift each day
+        # This represents how many distinct employees of type e are working in shift s on day t
+        EMPLOYEE_COUNT = {}
+        for e in employee_type_list:
+            for s in active_shift_list:
+                for t in date_span_list:
+                    # Note: Minimum staffing is per day, not per shift
+                    # We'll handle the daily minimum constraint separately
+                    max_count = max_employee_type_day.get(e, {}).get(t, 100)
+                    EMPLOYEE_COUNT[e, s, t] = solver.IntVar(
+                        0,  # No minimum per shift (daily minimum handled separately)
+                        max_count, 
+                        f"EmpCount_{e}_s{s}_day{t}"
+                    )
 
+        # Track total person-hours worked by each employee type per shift per day
+        # This is needed for employee-centric wage calculation
+        EMPLOYEE_HOURS = {}
+        for e in employee_type_list:
+            for s in active_shift_list:
+                for t in date_span_list:
+                    # Sum of all work hours for employee type e in shift s on day t
+                    # This represents total person-hours (e.g., 5 employees × 8 hours = 40 person-hours)
+                    EMPLOYEE_HOURS[e, s, t] = solver.Sum(
+                        TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t]
+                        for p in sorted_product_list
+                        for ell in line_tuples
+                    )
 
-    # --- Solver ---
-    solver = pywraplp.Solver.CreateSolver('CBC')
-    if not solver:
-        raise RuntimeError("CBC solver not found.")
-    INF = solver.infinity()
+        # Note: Binary variables for bulk payment are now created inline in the cost calculation
 
-    # --- Variables ---
-    # Assignment[p,ell,s,t] ∈ {0,1}: 1 if product p runs on (line,shift,day)
-    Assignment, Hours, Units = {}, {}, {}  # Hours: run hours, Units: production units
-    for p in sorted_product_list:
-        for ell in line_tuples:     # ell = (line_type_id, idx)
+        # --- Objective: Minimize total labor cost (wages) ---
+        # Employee-centric approach: calculate wages based on actual employees and their hours
+        print(f"\n[DEBUG] Payment mode configuration: {PAYMENT_MODE_CONFIG}")
+        
+        # Build cost terms based on payment mode
+        cost_terms = []
+        
+        for e in employee_type_list:
             for s in active_shift_list:
                 for t in date_span_list:
-                    #Is product p assigned to run on line ell, during shift s, on day t?
-                    Assignment[p, ell, s, t] = solver.BoolVar(f"Z_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
-                    #How many hours does product p run on line ell, during shift s, on day t?
-                    Hours[p, ell, s, t] = solver.NumVar(0, Hmax_s[s], f"T_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
-                    #How many units does product p run on line ell, during shift s, on day t?
-                    Units[p, ell, s, t] = solver.NumVar(0, INF,       f"U_{p}_{ell[0]}_{ell[1]}_s{s}_d{t}")
-    
-    # Note: IDLE variables removed - we only track employees actually working on production
-    
-    # Load fixed minimum UNICEF requirement (needed for EMPLOYEE_COUNT variable creation)
-    FIXED_MIN_UNICEF_PER_DAY = get_fixed_min_unicef_per_day()  # Dynamic call
-    
-    # Variable to track actual number of employees of each type working each shift each day
-    # This represents how many distinct employees of type e are working in shift s on day t
-    EMPLOYEE_COUNT = {}
-    for e in employee_type_list:
-        for s in active_shift_list:
-            for t in date_span_list:
-                # Note: Minimum staffing is per day, not per shift
-                # We'll handle the daily minimum constraint separately
-                max_count = max_employee_type_day.get(e, {}).get(t, 100)
-                EMPLOYEE_COUNT[e, s, t] = solver.IntVar(
-                    0,  # No minimum per shift (daily minimum handled separately)
-                    max_count, 
-                    f"EmpCount_{e}_s{s}_day{t}"
-                )
-
-    # Track total person-hours worked by each employee type per shift per day
-    # This is needed for employee-centric wage calculation
-    EMPLOYEE_HOURS = {}
-    for e in employee_type_list:
-        for s in active_shift_list:
-            for t in date_span_list:
-                # Sum of all work hours for employee type e in shift s on day t
-                # This represents total person-hours (e.g., 5 employees × 8 hours = 40 person-hours)
-                EMPLOYEE_HOURS[e, s, t] = solver.Sum(
-                    TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t]
-                    for p in sorted_product_list
-                    for ell in line_tuples
-                )
-
-    # Note: Binary variables for bulk payment are now created inline in the cost calculation
-
-    # --- Objective: Minimize total labor cost (wages) ---
-    # Employee-centric approach: calculate wages based on actual employees and their hours
-    PAYMENT_MODE_CONFIG = get_payment_mode_config()  # Dynamic call
-    print(f"Payment mode configuration: {PAYMENT_MODE_CONFIG}")
-    
-    # Build cost terms based on payment mode
-    cost_terms = []
-    
-    for e in employee_type_list:
-        for s in active_shift_list:
-            for t in date_span_list:
-                payment_mode = PAYMENT_MODE_CONFIG.get(s, "partial")  # Default to partial if not specified
-                
-                if payment_mode == "partial":
-                    # Partial payment: pay for actual person-hours worked
-                    # Cost = hourly_rate × total_person_hours
-                    # Example: $20/hr × 40 person-hours = $800
-                    cost_terms.append(cost[e][s] * EMPLOYEE_HOURS[e, s, t])
-                
-                elif payment_mode == "bulk":
-                    # Bulk payment: if ANY work happens in shift, pay ALL working employees for FULL shift
-                    # We need to know: did employee type e work at all in shift s on day t?
-                    
-                    # Create binary: 1 if employee type e worked in this shift
-                    work_in_shift = solver.BoolVar(f"work_{e}_s{s}_d{t}")
-                    
-                    # Link binary to work hours
-                    # If EMPLOYEE_HOURS > 0, then work_in_shift = 1
-                    # If EMPLOYEE_HOURS = 0, then work_in_shift = 0
-                    max_possible_hours = Hmax_s[s] * max_employee_type_day[e][t]
-                    solver.Add(EMPLOYEE_HOURS[e, s, t] <= max_possible_hours * work_in_shift)
-                    solver.Add(work_in_shift * 0.001 <= EMPLOYEE_HOURS[e, s, t])
+                    payment_mode = PAYMENT_MODE_CONFIG.get(s, "partial")  # Default to partial if not specified
                     
-                    # Calculate number of employees working in this shift
-                    # This is approximately: ceil(EMPLOYEE_HOURS / Hmax_s[s])
-                    # But we can use: employees_working_in_shift
-                    # For simplicity, use EMPLOYEE_HOURS / Hmax_s[s] as continuous approximation
-                    # Or better: create a variable for employees per shift
+                    if payment_mode == "partial":
+                        # Partial payment: pay for actual person-hours worked
+                        # Cost = hourly_rate × total_person_hours
+                        # Example: $20/hr × 40 person-hours = $800
+                        cost_terms.append(cost[e][s] * EMPLOYEE_HOURS[e, s, t])
                     
-                    # Simpler approach: For bulk payment, assume if work happens, 
-                    # we need approximately EMPLOYEE_HOURS/Hmax_s[s] employees,
-                    # and each gets paid for full shift
-                    # Cost ≈ (EMPLOYEE_HOURS / Hmax_s[s]) × Hmax_s[s] × hourly_rate = EMPLOYEE_HOURS × hourly_rate
-                    # But that's the same as partial! The difference is we round up employees.
-                    
-                    # Better approach: Create variable for employees working in this specific shift
-                    employees_in_shift = solver.IntVar(0, max_employee_type_day[e][t], f"emp_{e}_s{s}_d{t}")
-                    
-                    # Link employees_in_shift to work requirements
-                    # If EMPLOYEE_HOURS requires N employees, then employees_in_shift >= ceil(N)
-                    solver.Add(employees_in_shift * Hmax_s[s] >= EMPLOYEE_HOURS[e, s, t])
-                    
-                    # Cost: pay each employee for full shift
-                    cost_terms.append(cost[e][s] * Hmax_s[s] * employees_in_shift)
-    
-    # Note: No idle employee costs - only pay for employees actually working
-    
-    total_cost = solver.Sum(cost_terms)
-    
-    # Objective: minimize total labor cost (wages)
-    # This finds the optimal production schedule (product order, line assignment, timing)
-    # that minimizes total wages while meeting all demand and capacity constraints
-    solver.Minimize(total_cost)
-
-    # --- Constraints ---
-
-    # 1) Weekly demand - must meet exactly (no over/under production)
-    for p in sorted_product_list:
-        total_production = solver.Sum(Units[p, ell, s, t] for ell in line_tuples for s in active_shift_list for t in date_span_list)
-        demand = DEMAND_DICTIONARY.get(p, 0)
+                    elif payment_mode == "bulk":
+                        # Bulk payment: if ANY work happens in shift, pay ALL working employees for FULL shift
+                        # We need to know: did employee type e work at all in shift s on day t?
+                        
+                        # Create binary: 1 if employee type e worked in this shift
+                        work_in_shift = solver.BoolVar(f"work_{e}_s{s}_d{t}")
+                        
+                        # Link binary to work hours
+                        # If EMPLOYEE_HOURS > 0, then work_in_shift = 1
+                        # If EMPLOYEE_HOURS = 0, then work_in_shift = 0
+                        max_possible_hours = Hmax_s[s] * max_employee_type_day[e][t]
+                        solver.Add(EMPLOYEE_HOURS[e, s, t] <= max_possible_hours * work_in_shift)
+                        solver.Add(work_in_shift * 0.001 <= EMPLOYEE_HOURS[e, s, t])
+                        
+                        # Calculate number of employees working in this shift
+                        # This is approximately: ceil(EMPLOYEE_HOURS / Hmax_s[s])
+                        # But we can use: employees_working_in_shift
+                        # For simplicity, use EMPLOYEE_HOURS / Hmax_s[s] as continuous approximation
+                        # Or better: create a variable for employees per shift
+                        
+                        # Simpler approach: For bulk payment, assume if work happens, 
+                        # we need approximately EMPLOYEE_HOURS/Hmax_s[s] employees,
+                        # and each gets paid for full shift
+                        # Cost ≈ (EMPLOYEE_HOURS / Hmax_s[s]) × Hmax_s[s] × hourly_rate = EMPLOYEE_HOURS × hourly_rate
+                        # But that's the same as partial! The difference is we round up employees.
+                        
+                        # Better approach: Create variable for employees working in this specific shift
+                        employees_in_shift = solver.IntVar(0, max_employee_type_day[e][t], f"emp_{e}_s{s}_d{t}")
+                        
+                        # Link employees_in_shift to work requirements
+                        # If EMPLOYEE_HOURS requires N employees, then employees_in_shift >= ceil(N)
+                        solver.Add(employees_in_shift * Hmax_s[s] >= EMPLOYEE_HOURS[e, s, t])
+                        
+                        # Cost: pay each employee for full shift
+                        cost_terms.append(cost[e][s] * Hmax_s[s] * employees_in_shift)
+        
+        # Note: No idle employee costs - only pay for employees actually working
         
-        # Must produce at least the demand
-        solver.Add(total_production >= demand)
+        total_cost = solver.Sum(cost_terms)
         
-        # Must not produce more than the demand (prevent overproduction)
-        solver.Add(total_production <= demand)
+        # Objective: minimize total labor cost (wages)
+        # This finds the optimal production schedule (product order, line assignment, timing)
+        # that minimizes total wages while meeting all demand and capacity constraints
+        solver.Minimize(total_cost)
 
-    # 2) One product per (line,shift,day) + time gating
-    for ell in line_tuples:
-        for s in active_shift_list:
-            for t in date_span_list:
-                solver.Add(solver.Sum(Assignment[p, ell, s, t] for p in sorted_product_list) <= 1)
-                for p in sorted_product_list:
-                    solver.Add(Hours[p, ell, s, t] <= Hmax_s[s] * Assignment[p, ell, s, t])
-
-    # 3) Product-line type compatibility + (optional) activity by day
-    for p in sorted_product_list:
-        req_lt = KIT_LINE_MATCH_DICT.get(p, LineType.LONG_LINE)  # Default to long line if not found
-        req_total = sum(TEAM_REQ_PER_PRODUCT[e][p] for e in employee_type_list)
+        # --- Constraints ---
+
+        # 1) Weekly demand - must meet exactly (no over/under production)
+        for p in sorted_product_list:
+            total_production = solver.Sum(Units[p, ell, s, t] for ell in line_tuples for s in active_shift_list for t in date_span_list)
+            demand = DEMAND_DICTIONARY.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 line_tuples:
-            allowed = (ell[0] == req_lt) and (req_total <= max_workers_line.get(ell[0], 1e9))
             for s in active_shift_list:
                 for t in date_span_list:
-                    if ACTIVE[t][p] == 0 or not allowed:
-                        solver.Add(Assignment[p, ell, s, t] == 0)
-                        solver.Add(Hours[p, ell, s, t] == 0)
-                        solver.Add(Units[p, ell, s, t] == 0)
+                    solver.Add(solver.Sum(Assignment[p, ell, s, t] for p in sorted_product_list) <= 1)
+                    for p in sorted_product_list:
+                        solver.Add(Hours[p, ell, s, t] <= Hmax_s[s] * Assignment[p, ell, s, t])
 
-    # 4) Line throughput: Units ≤ product_speed * Hours
-    for p in sorted_product_list:
-        for ell in line_tuples:
+        # 3) Product-line type compatibility + (optional) activity by day
+        for p in sorted_product_list:
+            req_lt = KIT_LINE_MATCH_DICT.get(p, LineType.LONG_LINE)  # Default to long line if not found
+            req_total = sum(TEAM_REQ_PER_PRODUCT[e][p] for e in employee_type_list)
+            for ell in line_tuples:
+                allowed = (ell[0] == req_lt) and (req_total <= max_workers_line.get(ell[0], 1e9))
+                for s in active_shift_list:
+                    for t in date_span_list:
+                        if ACTIVE[t][p] == 0 or not allowed:
+                            solver.Add(Assignment[p, ell, s, t] == 0)
+                            solver.Add(Hours[p, ell, s, t] == 0)
+                            solver.Add(Units[p, ell, s, t] == 0)
+
+        # 4) Line throughput: Units ≤ product_speed * Hours
+        for p in sorted_product_list:
+            for ell in line_tuples:
+                for s in active_shift_list:
+                    for t in date_span_list:
+                        # Get product speed (same speed regardless of line type)
+                        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(
+                                Units[p, ell, s, t] <= speed * Hours[p, ell, s, t]
+                            )
+                            # Lower bound: if working, must produce (prevent phantom work)
+                            solver.Add(
+                                Units[p, ell, s, t] >= speed * Hours[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(
+                                Units[p, ell, s, t] <= default_speed * Hours[p, ell, s, t]
+                            )
+                            # Lower bound: if working, must produce (prevent phantom work)
+                            solver.Add(
+                                Units[p, ell, s, t] >= default_speed * Hours[p, ell, s, t]
+                            )
+
+        # Working hours constraint: active employees cannot exceed shift hour capacity
+        for e in employee_type_list:
             for s in active_shift_list:
                 for t in date_span_list:
-                    # Get product speed (same speed regardless of line type)
-                    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(
-                            Units[p, ell, s, t] <= speed * Hours[p, ell, s, t]
-                        )
-                        # Lower bound: if working, must produce (prevent phantom work)
-                        solver.Add(
-                            Units[p, ell, s, t] >= speed * Hours[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(
-                            Units[p, ell, s, t] <= default_speed * Hours[p, ell, s, t]
-                        )
-                        # Lower bound: if working, must produce (prevent phantom work)
-                        solver.Add(
-                            Units[p, ell, s, t] >= default_speed * Hours[p, ell, s, t]
-                        )
+                    # No idle employee constraints - employees are only counted when working
+                    solver.Add(
+                        solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t] for p in sorted_product_list for ell in line_tuples)
+                        <= Hmax_s[s] * max_employee_type_day[e][t]
+                    )
 
-    # Working hours constraint: active employees cannot exceed shift hour capacity
-    for e in employee_type_list:
-        for s in active_shift_list:
-            for t in date_span_list:
-                # No idle employee constraints - employees are only counted when working
-                solver.Add(
-                    solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t] for p in sorted_product_list for ell in line_tuples)
-                    <= Hmax_s[s] * max_employee_type_day[e][t]
-                )
-
-    # 6) Per-shift staffing capacity by type: link employee count to actual work hours
-    # This constraint ensures EMPLOYEE_COUNT[e,s,t] represents the actual number of employees needed in each shift
-    for e in employee_type_list:
-        for s in active_shift_list:
-            for t in date_span_list:
-                # Total person-hours worked by employee type e in shift s on day t
-                total_person_hours_in_shift = solver.Sum(
-                    TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t] 
-                    for p in sorted_product_list 
-                    for ell in line_tuples
-                )
-                
-                # Employee count must be sufficient to cover the work in this shift
-                # If employees work H person-hours total and each can work max M hours/shift,
-                # then we need at least ceil(H/M) employees
-                # Constraint: employee_count × max_hours_per_shift >= total_person_hours_in_shift
-                solver.Add(EMPLOYEE_COUNT[e, s, t] * Hmax_s[s] >= total_person_hours_in_shift)
-
-    # 7) Shift ordering constraints (only apply if shifts are available)
-    # Evening shift after regular shift
-    if ShiftType.EVENING in active_shift_list and ShiftType.REGULAR in active_shift_list:  # Only if both shifts are available
+        # 6) Per-shift staffing capacity by type: link employee count to actual work hours
+        # This constraint ensures EMPLOYEE_COUNT[e,s,t] represents the actual number of employees needed in each shift
         for e in employee_type_list:
-            for t in date_span_list:
-                solver.Add(
-                    solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.EVENING, t] for p in sorted_product_list for ell in line_tuples)
-                    <=
-                    solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.REGULAR, t] for p in sorted_product_list for ell in line_tuples)
-                )
-    
-    # Overtime should only be used when regular shift is at capacity
-    if ShiftType.OVERTIME in active_shift_list and ShiftType.REGULAR in active_shift_list:  # Only if both shifts are available
-        print("\n[OVERTIME] Adding constraints to ensure overtime only when regular shift is insufficient...")
+            for s in active_shift_list:
+                for t in date_span_list:
+                    # Total person-hours worked by employee type e in shift s on day t
+                    total_person_hours_in_shift = solver.Sum(
+                        TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t] 
+                        for p in sorted_product_list 
+                        for ell in line_tuples
+                    )
+                    
+                    # Employee count must be sufficient to cover the work in this shift
+                    # If employees work H person-hours total and each can work max M hours/shift,
+                    # then we need at least ceil(H/M) employees
+                    # Constraint: employee_count × max_hours_per_shift >= total_person_hours_in_shift
+                    solver.Add(EMPLOYEE_COUNT[e, s, t] * Hmax_s[s] >= total_person_hours_in_shift)
+
+        # 7) Shift ordering constraints (only apply if shifts are available)
+        # Evening shift after regular shift
+        if ShiftType.EVENING in active_shift_list and ShiftType.REGULAR in active_shift_list:  # Only if both shifts are available
+            for e in employee_type_list:
+                for t in date_span_list:
+                    solver.Add(
+                        solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.EVENING, t] for p in sorted_product_list for ell in line_tuples)
+                        <=
+                        solver.Sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.REGULAR, t] for p in sorted_product_list for ell in line_tuples)
+                    )
         
-        for e in employee_type_list:
-            for t in date_span_list:
-                # Get available regular capacity for this employee type and day
-                regular_capacity = max_employee_type_day[e][t]
-                
-                # Total regular shift usage for this employee type and day
-                regular_usage = solver.Sum(
-                    TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.REGULAR, t] 
-                    for p in sorted_product_list for ell in line_tuples
-                )
-                
-                # Total overtime usage for this employee type and day
-                overtime_usage = solver.Sum(
-                    TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.OVERTIME, t] 
-                    for p in sorted_product_list for ell in line_tuples
-                )
-                
-                # 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(employee_type_list) * len(date_span_list) * 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 work in the REGULAR shift every day
-    # The minimum applies to the regular shift specifically (not overtime or evening)
-    if 'UNICEF Fixed term' in employee_type_list and FIXED_MIN_UNICEF_PER_DAY > 0:
-        if ShiftType.REGULAR in active_shift_list:
-            print(f"\n[FIXED STAFFING] Adding constraint for minimum {FIXED_MIN_UNICEF_PER_DAY} UNICEF employees in REGULAR shift per day...")
-            for t in date_span_list:
-                # At least FIXED_MIN_UNICEF_PER_DAY employees must work in the regular shift each day
-                solver.Add(
-                    EMPLOYEE_COUNT['UNICEF Fixed term', ShiftType.REGULAR, t] >= FIXED_MIN_UNICEF_PER_DAY
-                )
-            print(f"[FIXED STAFFING] Added {len(date_span_list)} constraints ensuring >= {FIXED_MIN_UNICEF_PER_DAY} UNICEF employees in regular shift per day")
-        else:
-            print(f"\n[FIXED STAFFING] Warning: Regular shift not available, cannot enforce minimum UNICEF staffing")
-    
-    # 8) *** HIERARCHY DEPENDENCY CONSTRAINTS ***
-    # For subkits with prepack dependencies: dependencies should be produced before or same time
-    print("\n[HIERARCHY] Adding dependency constraints...")
-    dependency_constraints_added = 0
-    
-    for p in sorted_product_list:
-        dependencies = KIT_DEPENDENCIES.get(p, [])
-        if dependencies:
-            # Get the level of the current product
-            p_level = KIT_LEVELS.get(p, 2)
+        # Overtime should only be used when regular shift is at capacity
+        if ShiftType.OVERTIME in active_shift_list and ShiftType.REGULAR in active_shift_list:  # Only if both shifts are available
+            print("\n[OVERTIME] Adding constraints to ensure overtime only when regular shift is insufficient...")
             
-            for dep in dependencies:
-                if dep in sorted_product_list:  # Only if dependency is also in production list
-                    # Calculate "completion time" for each product (sum of all production times)
-                    p_completion = solver.Sum(
-                        t * Hours[p, ell, s, t] for ell in line_tuples for s in active_shift_list for t in date_span_list
+            for e in employee_type_list:
+                for t in date_span_list:
+                    # Get available regular capacity for this employee type and day
+                    regular_capacity = max_employee_type_day[e][t]
+                    
+                    # Total regular shift usage for this employee type and day
+                    regular_usage = solver.Sum(
+                        TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.REGULAR, t] 
+                        for p in sorted_product_list for ell in line_tuples
                     )
-                    dep_completion = solver.Sum(
-                        t * Hours[dep, ell, s, t] for ell in line_tuples for s in active_shift_list for t in date_span_list
+                    
+                    # Total overtime usage for this employee type and day
+                    overtime_usage = solver.Sum(
+                        TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, ShiftType.OVERTIME, t] 
+                        for p in sorted_product_list for ell in line_tuples
                     )
                     
-                    # Dependency should complete before or at the same time
-                    solver.Add(dep_completion <= p_completion)
-                    dependency_constraints_added += 1
+                    # Create binary variable: 1 if using overtime, 0 otherwise
+                    using_overtime = solver.IntVar(0, 1, f'using_overtime_{e}_{t}')
                     
-                    print(f"  Added constraint: {dep} (dependency) <= {p} (level {p_level})")
-    
-    print(f"[HIERARCHY] Added {dependency_constraints_added} dependency constraints")
-
-    # --- Solve ---
-    status = solver.Solve()
-    if status != pywraplp.Solver.OPTIMAL:
-        status_names = {pywraplp.Solver.INFEASIBLE: "INFEASIBLE", pywraplp.Solver.UNBOUNDED: "UNBOUNDED"}
-        print(f"No optimal solution. Status: {status} ({status_names.get(status, 'UNKNOWN')})")
-        # Debug hint:
-        # solver.EnableOutput()
-        # solver.ExportModelAsLpFile("model.lp")
-        return None
-
-    # --- Report ---
-    result = {}
-    result['objective'] = solver.Objective().Value()
-
-    # Weekly production
-    prod_week = {p: sum(Units[p, ell, s, t].solution_value() for ell in line_tuples for s in active_shift_list for t in date_span_list) for p in sorted_product_list}
-    result['weekly_production'] = prod_week
-
-    # Which product ran on which line/shift/day
-    schedule = []
-    for t in date_span_list:
-        for ell in line_tuples:
+                    # 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(employee_type_list) * len(date_span_list) * 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 work in the REGULAR shift every day
+        # The minimum applies to the regular shift specifically (not overtime or evening)
+        if 'UNICEF Fixed term' in employee_type_list and FIXED_MIN_UNICEF_PER_DAY > 0:
+            if ShiftType.REGULAR in active_shift_list:
+                print(f"\n[FIXED STAFFING] Adding constraint for minimum {FIXED_MIN_UNICEF_PER_DAY} UNICEF employees in REGULAR shift per day...")
+                for t in date_span_list:
+                    # At least FIXED_MIN_UNICEF_PER_DAY employees must work in the regular shift each day
+                    solver.Add(
+                        EMPLOYEE_COUNT['UNICEF Fixed term', ShiftType.REGULAR, t] >= FIXED_MIN_UNICEF_PER_DAY
+                    )
+                print(f"[FIXED STAFFING] Added {len(date_span_list)} constraints ensuring >= {FIXED_MIN_UNICEF_PER_DAY} UNICEF employees in regular shift per day")
+            else:
+                print(f"\n[FIXED STAFFING] Warning: Regular shift not available, cannot enforce minimum UNICEF staffing")
+        
+        # 8) *** HIERARCHY DEPENDENCY CONSTRAINTS ***
+        # For subkits with prepack dependencies: dependencies should be produced before or same time
+        print("\n[HIERARCHY] Adding dependency constraints...")
+        dependency_constraints_added = 0
+        
+        for p in sorted_product_list:
+            dependencies = KIT_DEPENDENCIES.get(p, [])
+            if dependencies:
+                # Get the level of the current product
+                p_level = KIT_LEVELS.get(p, 2)
+                
+                for dep in dependencies:
+                    if dep in sorted_product_list:  # Only if dependency is also in production list
+                        # Calculate "completion time" for each product (sum of all production times)
+                        p_completion = solver.Sum(
+                            t * Hours[p, ell, s, t] for ell in line_tuples for s in active_shift_list for t in date_span_list
+                        )
+                        dep_completion = solver.Sum(
+                            t * Hours[dep, ell, s, t] for ell in line_tuples for s in active_shift_list for t in date_span_list
+                        )
+                        
+                        # Dependency should complete before or at the same time
+                        solver.Add(dep_completion <= p_completion)
+                        dependency_constraints_added += 1
+                        
+                        print(f"  Added constraint: {dep} (dependency) <= {p} (level {p_level})")
+        
+        print(f"[HIERARCHY] Added {dependency_constraints_added} dependency constraints")
+
+        # --- Solve ---
+        status = solver.Solve()
+        if status != pywraplp.Solver.OPTIMAL:
+            status_names = {pywraplp.Solver.INFEASIBLE: "INFEASIBLE", pywraplp.Solver.UNBOUNDED: "UNBOUNDED"}
+            print(f"No optimal solution. Status: {status} ({status_names.get(status, 'UNKNOWN')})")
+            # Debug hint:
+            # solver.EnableOutput()
+            # solver.ExportModelAsLpFile("model.lp")
+            return None
+
+        # --- Report ---
+        result = {}
+        result['objective'] = solver.Objective().Value()
+
+        # Weekly production
+        prod_week = {p: sum(Units[p, ell, s, t].solution_value() for ell in line_tuples for s in active_shift_list for t in date_span_list) for p in sorted_product_list}
+        result['weekly_production'] = prod_week
+
+        # Which product ran on which line/shift/day
+        schedule = []
+        for t in date_span_list:
+            for ell in line_tuples:
+                for s in active_shift_list:
+                    chosen = [p for p in sorted_product_list if Assignment[p, ell, s, t].solution_value() > 0.5]
+                    if chosen:
+                        p = chosen[0]
+                        schedule.append({
+                            'day': t,
+                            'line_type_id': ell[0],
+                            'line_idx': ell[1],
+                            'shift': s,
+                            'product': p,
+                            'run_hours': Hours[p, ell, s, t].solution_value(),
+                            'units': Units[p, ell, s, t].solution_value(),
+                        })
+        result['run_schedule'] = schedule
+
+        # Implied headcount by type/shift/day (ceil)
+        headcount = []
+        for e in employee_type_list:
             for s in active_shift_list:
-                chosen = [p for p in sorted_product_list if Assignment[p, ell, s, t].solution_value() > 0.5]
-                if chosen:
-                    p = chosen[0]
-                    schedule.append({
-                        'day': t,
-                        'line_type_id': ell[0],
-                        'line_idx': ell[1],
-                        'shift': s,
-                        'product': p,
-                        'run_hours': Hours[p, ell, s, t].solution_value(),
-                        'units': Units[p, ell, s, t].solution_value(),
-                    })
-    result['run_schedule'] = schedule
-
-    # Implied headcount by type/shift/day (ceil)
-    headcount = []
-    for e in employee_type_list:
-        for s in active_shift_list:
+                for t in date_span_list:
+                    used_ph = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() for p in sorted_product_list for ell in line_tuples)
+                    need = ceil(used_ph / (Hmax_s[s] + 1e-9))
+                    headcount.append({'emp_type': e, 'shift': s, 'day': t,
+                                    'needed': need, 'available': max_employee_type_day[e][t]})
+        result['headcount_per_shift'] = headcount
+
+        # Total person-hours by type/day (≤ 14h * headcount)
+        ph_by_day = []
+        for e in employee_type_list:
             for t in date_span_list:
-                used_ph = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() for p in sorted_product_list for ell in line_tuples)
-                need = ceil(used_ph / (Hmax_s[s] + 1e-9))
-                headcount.append({'emp_type': e, 'shift': s, 'day': t,
-                                  'needed': need, 'available': max_employee_type_day[e][t]})
-    result['headcount_per_shift'] = headcount
-
-    # Total person-hours by type/day (≤ 14h * headcount)
-    ph_by_day = []
-    for e in employee_type_list:
-        for t in date_span_list:
-            used = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() for s in active_shift_list for p in sorted_product_list for ell in line_tuples)
-            ph_by_day.append({'emp_type': e, 'day': t,
-                              'used_person_hours': used,
-                              'cap_person_hours': Hmax_daily * max_employee_type_day[e][t]})
-    result['person_hours_by_day'] = ph_by_day
-
-    # Actual employee count per type/shift/day (from EMPLOYEE_COUNT variable)
-    employee_count_by_shift = []
-    for e in employee_type_list:
-        for s in active_shift_list:
+                used = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() for s in active_shift_list for p in sorted_product_list for ell in line_tuples)
+                ph_by_day.append({'emp_type': e, 'day': t,
+                                'used_person_hours': used,
+                                'cap_person_hours': Hmax_daily * max_employee_type_day[e][t]})
+        result['person_hours_by_day'] = ph_by_day
+
+        # Actual employee count per type/shift/day (from EMPLOYEE_COUNT variable)
+        employee_count_by_shift = []
+        for e in employee_type_list:
+            for s in active_shift_list:
+                for t in date_span_list:
+                    count = int(EMPLOYEE_COUNT[e, s, t].solution_value())
+                    used_hours = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() 
+                                for p in sorted_product_list for ell in line_tuples)
+                    avg_hours_per_employee = used_hours / count if count > 0 else 0
+                    if count > 0:  # Only add entries where employees are working
+                        employee_count_by_shift.append({
+                            'emp_type': e, 
+                            'shift': s,
+                            'day': t,
+                            'employee_count': count,
+                            'total_person_hours': used_hours,
+                            'avg_hours_per_employee': avg_hours_per_employee,
+                            'available': max_employee_type_day[e][t]
+                        })
+        result['employee_count_by_shift'] = employee_count_by_shift
+        
+        # Also calculate daily totals (summing across shifts)
+        employee_count_by_day = []
+        for e in employee_type_list:
             for t in date_span_list:
-                count = int(EMPLOYEE_COUNT[e, s, t].solution_value())
+                # Sum employees across all shifts for this day
+                total_count = sum(int(EMPLOYEE_COUNT[e, s, t].solution_value()) for s in active_shift_list)
                 used_hours = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() 
-                               for p in sorted_product_list for ell in line_tuples)
-                avg_hours_per_employee = used_hours / count if count > 0 else 0
-                if count > 0:  # Only add entries where employees are working
-                    employee_count_by_shift.append({
+                            for s in active_shift_list for p in sorted_product_list for ell in line_tuples)
+                avg_hours_per_employee = used_hours / total_count if total_count > 0 else 0
+                if total_count > 0:  # Only add days where employees are working
+                    employee_count_by_day.append({
                         'emp_type': e, 
-                        'shift': s,
                         'day': t,
-                        'employee_count': count,
+                        'employee_count': total_count,
                         'total_person_hours': used_hours,
                         'avg_hours_per_employee': avg_hours_per_employee,
                         'available': max_employee_type_day[e][t]
                     })
-    result['employee_count_by_shift'] = employee_count_by_shift
-    
-    # Also calculate daily totals (summing across shifts)
-    employee_count_by_day = []
-    for e in employee_type_list:
-        for t in date_span_list:
-            # Sum employees across all shifts for this day
-            total_count = sum(int(EMPLOYEE_COUNT[e, s, t].solution_value()) for s in active_shift_list)
-            used_hours = sum(TEAM_REQ_PER_PRODUCT[e][p] * Hours[p, ell, s, t].solution_value() 
-                           for s in active_shift_list for p in sorted_product_list for ell in line_tuples)
-            avg_hours_per_employee = used_hours / total_count if total_count > 0 else 0
-            if total_count > 0:  # Only add days where employees are working
-                employee_count_by_day.append({
-                    'emp_type': e, 
-                    'day': t,
-                    'employee_count': total_count,
-                    'total_person_hours': used_hours,
-                    'avg_hours_per_employee': avg_hours_per_employee,
-                    'available': max_employee_type_day[e][t]
-                })
-    result['employee_count_by_day'] = employee_count_by_day
-
-    # Note: Idle employee tracking removed - only counting employees actually working
-
-    # Pretty print
-    print("Objective (min cost):", result['objective'])
-    print("\n--- Weekly production by product ---")
-    for p, u in prod_week.items():
-        print(f"{p}: {u:.1f} / demand {DEMAND_DICTIONARY.get(p,0)}")
-
-    print("\n--- Schedule (line, shift, day) ---")
-    for row in schedule:
-        shift_name = ShiftType.get_name(row['shift'])
-        line_name = LineType.get_name(row['line_type_id'])
-        print(f"date_span_list{row['day']} {line_name}-{row['line_idx']} {shift_name}: "
-              f"{row['product']}  Hours={row['run_hours']:.2f}h  Units={row['units']:.1f}")
-
-    print("\n--- Implied headcount need (per type/shift/day) ---")
-    for row in headcount:
-        shift_name = ShiftType.get_name(row['shift'])
-        print(f"{row['emp_type']}, {shift_name}, date_span_list{row['day']}: "
-              f"need={row['needed']} (avail {row['available']})")
-
-    print("\n--- Total person-hours by type/day ---")
-    for row in ph_by_day:
-        print(f"{row['emp_type']}, date_span_list{row['day']}: used={row['used_person_hours']:.1f} "
-              f"(cap {row['cap_person_hours']})")
-
-    print("\n--- Actual employee count by type/shift/day ---")
-    for row in employee_count_by_shift:
-        shift_name = ShiftType.get_name(row['shift'])
-        print(f"{row['emp_type']}, {shift_name}, date_span_list{row['day']}: "
-              f"count={row['employee_count']} employees, "
-              f"total_hours={row['total_person_hours']:.1f}h, "
-              f"avg={row['avg_hours_per_employee']:.1f}h/employee")
-    
-    print("\n--- Daily employee totals by type/day (sum across shifts) ---")
-    for row in employee_count_by_day:
-        print(f"{row['emp_type']}, date_span_list{row['day']}: "
-              f"count={row['employee_count']} employees total, "
-              f"total_hours={row['total_person_hours']:.1f}h, "
-              f"avg={row['avg_hours_per_employee']:.1f}h/employee "
-              f"(available: {row['available']})")
+        result['employee_count_by_day'] = employee_count_by_day
+
+        # Note: Idle employee tracking removed - only counting employees actually working
+
+        # Pretty print
+        print("Objective (min cost):", result['objective'])
+        print("\n--- Weekly production by product ---")
+        for p, u in prod_week.items():
+            print(f"{p}: {u:.1f} / demand {DEMAND_DICTIONARY.get(p,0)}")
+
+        print("\n--- Schedule (line, shift, day) ---")
+        for row in schedule:
+            shift_name = ShiftType.get_name(row['shift'])
+            line_name = LineType.get_name(row['line_type_id'])
+            print(f"date_span_list{row['day']} {line_name}-{row['line_idx']} {shift_name}: "
+                f"{row['product']}  Hours={row['run_hours']:.2f}h  Units={row['units']:.1f}")
+
+        print("\n--- Implied headcount need (per type/shift/day) ---")
+        for row in headcount:
+            shift_name = ShiftType.get_name(row['shift'])
+            print(f"{row['emp_type']}, {shift_name}, date_span_list{row['day']}: "
+                f"need={row['needed']} (avail {row['available']})")
+
+        print("\n--- Total person-hours by type/day ---")
+        for row in ph_by_day:
+            print(f"{row['emp_type']}, date_span_list{row['day']}: used={row['used_person_hours']:.1f} "
+                f"(cap {row['cap_person_hours']})")
+
+        print("\n--- Actual employee count by type/shift/day ---")
+        for row in employee_count_by_shift:
+            shift_name = ShiftType.get_name(row['shift'])
+            print(f"{row['emp_type']}, {shift_name}, date_span_list{row['day']}: "
+                f"count={row['employee_count']} employees, "
+                f"total_hours={row['total_person_hours']:.1f}h, "
+                f"avg={row['avg_hours_per_employee']:.1f}h/employee")
+        
+        print("\n--- Daily employee totals by type/day (sum across shifts) ---")
+        for row in employee_count_by_day:
+            print(f"{row['emp_type']}, date_span_list{row['day']}: "
+                f"count={row['employee_count']} employees total, "
+                f"total_hours={row['total_person_hours']:.1f}h, "
+                f"avg={row['avg_hours_per_employee']:.1f}h/employee "
+                f"(available: {row['available']})")
 
-    # Note: Idle employee reporting removed - only tracking employees actually working
+            # Note: Idle employee reporting removed - only tracking employees actually working
 
-    return result
+        return result
 
 
 if __name__ == "__main__":
-    run_optimization_for_week()
+    optimizer = Optimizer()
+    optimizer.run_optimization()

src/preprocess/hierarchy_parser.py

@@ -107,6 +107,99 @@ class KitHierarchyParser:
 
 
 
+def sort_products_by_hierarchy(product_list: List[str], 
+                                kit_levels: Dict[str, int], 
+                                kit_dependencies: Dict[str, List[str]]) -> List[str]:
+    """
+    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.
+    
+    Args:
+        product_list: List of product names to sort
+        kit_levels: Dictionary mapping product names to hierarchy levels (0=prepack, 1=subkit, 2=master)
+        kit_dependencies: Dictionary mapping product names to their dependencies (products that must be made first)
+    
+    Returns:
+        List of products sorted in production order (dependencies first)
+    """
+    # 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]
+    
+    if products_without_hierarchy:
+        print(f"[HIERARCHY] Products without hierarchy data: {products_without_hierarchy}")
+    
+    # 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
+    
+    for product in products_with_hierarchy:
+        deps = kit_dependencies.get(product, [])  # dependencies = products that has to be packed first
+        for dep in deps:
+            if dep in products_with_hierarchy:  # Only if dependency is in our production list
+                # REVERSE THE RELATIONSHIP: 
+                # kit_dependencies says: "product needs dep"
+                # graph says: "dep is needed by product"
+                graph[dep].append(product)  # dep -> product (reverse the relationship!)
+                in_degree[product] += 1
+    
+    # Topological sort with hierarchy level priority
+    sorted_products = []
+    # queue = able to remove from both sides
+    queue = deque()
+    
+    # Start with products that have no dependencies
+    for product in products_with_hierarchy:
+        if in_degree[product] == 0:
+            queue.append(product)
+    
+    while queue:
+        current = queue.popleft()
+        sorted_products.append(current)
+        
+        # Process dependents - sort by hierarchy level first
+        for dependent in sorted(graph[current], key=lambda p: (kit_levels.get(p, 999), p)):
+            in_degree[dependent] -= 1  # decrement the in_degree of the dependent
+            if in_degree[dependent] == 0:  # if the in_degree of the dependent is 0, add it to the queue so that it can be processed
+                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 information at the end
+    sorted_products.extend(sorted(products_without_hierarchy))
+    
+    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")
+        # Import here to avoid circular dependency
+        try:
+            from src.config.constants import KitLevel
+            level_name = KitLevel.get_name(level)
+        except:
+            level_name = f"level_{level}"
+        deps = kit_dependencies.get(p, [])
+        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 main():
     """Demo the hierarchy parser"""
     parser = KitHierarchyParser()

ui/pages/config_page.py

@@ -8,7 +8,24 @@ import datetime
 import sys
 import os
 from src.config import optimization_config
-from src.config.constants import ShiftType, LineType
+from src.config.constants import ShiftType, LineType, DefaultConfig
+
+def clear_optimization_cache():
+    """Clear all cached optimization results and validation data"""
+    # Clear any previous optimization results since settings changed
+    if 'optimization_results' in st.session_state:
+        del st.session_state.optimization_results
+    
+    # Clear any previous validation state
+    if 'show_validation_after_save' in st.session_state:
+        del st.session_state.show_validation_after_save
+    if 'settings_just_saved' in st.session_state:
+        del st.session_state.settings_just_saved
+    
+    # Clear any cached validation results since settings changed
+    validation_cache_key = f"validation_results_{st.session_state.get('start_date', 'default')}"
+    if validation_cache_key in st.session_state:
+        del st.session_state[validation_cache_key]
 
 def render_config_page():
     """Render the configuration page with all user input controls"""
@@ -48,20 +65,8 @@ def render_config_page():
             config = save_configuration()
             st.success("✅ Settings saved successfully!")
             
-            # Clear any previous optimization results since settings changed
-            if 'optimization_results' in st.session_state:
-                del st.session_state.optimization_results
-            
-            # Clear any previous validation state
-            if 'show_validation_after_save' in st.session_state:
-                del st.session_state.show_validation_after_save
-            if 'settings_just_saved' in st.session_state:
-                del st.session_state.settings_just_saved
-            
-            # Clear any cached validation results since settings changed
-            validation_cache_key = f"validation_results_{st.session_state.get('start_date', 'default')}"
-            if validation_cache_key in st.session_state:
-                del st.session_state[validation_cache_key]
+            # Clear all cached optimization and validation data
+            clear_optimization_cache()
             
             # Trigger fresh demand validation after saving settings
             st.session_state.show_validation_after_save = True
@@ -245,56 +250,56 @@ def render_config_page():
         display_optimization_results(st.session_state.optimization_results)
 
 def initialize_session_state():
-    """Initialize session state with simple default values using Streamlit's standard pattern"""
+    """Initialize session state with default values from constants.py"""
     
-    # Simple default values - no complex imports or function calls
+    # Use constants from DefaultConfig - no more hardcoded values
     # Use setdefault to avoid overwriting existing values
     
     # Schedule defaults
     st.session_state.setdefault('start_date', datetime.date(2025, 7, 7))
-    st.session_state.setdefault('schedule_type', 'weekly')
+    st.session_state.setdefault('schedule_type', DefaultConfig.SCHEDULE_TYPE)
     
     # Shift defaults
-    st.session_state.setdefault('evening_shift_mode', 'normal')
-    st.session_state.setdefault('evening_shift_threshold', 0.9)
+    st.session_state.setdefault('evening_shift_mode', DefaultConfig.EVENING_SHIFT_MODE)
+    st.session_state.setdefault('evening_shift_threshold', DefaultConfig.EVENING_SHIFT_DEMAND_THRESHOLD)
     
     # Staff defaults
-    st.session_state.setdefault('fixed_staff_mode', 'priority')
-    st.session_state.setdefault('fixed_min_unicef_per_day', 5)
+    st.session_state.setdefault('fixed_staff_mode', DefaultConfig.FIXED_STAFF_MODE)
+    st.session_state.setdefault('fixed_min_unicef_per_day', DefaultConfig.FIXED_MIN_UNICEF_PER_DAY)
     
     # Payment modes
-    st.session_state.setdefault('payment_mode_shift_1', 'bulk')
-    st.session_state.setdefault('payment_mode_shift_2', 'bulk')
-    st.session_state.setdefault('payment_mode_shift_3', 'partial')
+    st.session_state.setdefault('payment_mode_shift_1', DefaultConfig.PAYMENT_MODE_CONFIG[ShiftType.REGULAR])
+    st.session_state.setdefault('payment_mode_shift_2', DefaultConfig.PAYMENT_MODE_CONFIG[ShiftType.EVENING])
+    st.session_state.setdefault('payment_mode_shift_3', DefaultConfig.PAYMENT_MODE_CONFIG[ShiftType.OVERTIME])
     
     # Working hours
-    st.session_state.setdefault('max_hour_per_person_per_day', 14)
-    st.session_state.setdefault('max_hours_shift_1', 9.0)
-    st.session_state.setdefault('max_hours_shift_2', 7.0)
-    st.session_state.setdefault('max_hours_shift_3', 4.0)
+    st.session_state.setdefault('max_hour_per_person_per_day', DefaultConfig.MAX_HOUR_PER_PERSON_PER_DAY)
+    st.session_state.setdefault('max_hours_shift_1', DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.REGULAR])
+    st.session_state.setdefault('max_hours_shift_2', DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.EVENING])
+    st.session_state.setdefault('max_hours_shift_3', DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.OVERTIME])
     
     # Workforce limits
-    st.session_state.setdefault('max_unicef_per_day', 8)
-    st.session_state.setdefault('max_humanizer_per_day', 10)
+    st.session_state.setdefault('max_unicef_per_day', DefaultConfig.MAX_UNICEF_PER_DAY)
+    st.session_state.setdefault('max_humanizer_per_day', DefaultConfig.MAX_HUMANIZER_PER_DAY)
     
     # Operations
-    st.session_state.setdefault('line_count_long_line', 3)
-    st.session_state.setdefault('line_count_mini_load', 2)
-    st.session_state.setdefault('max_parallel_workers_long_line', 7)
-    st.session_state.setdefault('max_parallel_workers_mini_load', 5)
+    st.session_state.setdefault('line_count_long_line', DefaultConfig.LINE_COUNT_LONG_LINE)
+    st.session_state.setdefault('line_count_mini_load', DefaultConfig.LINE_COUNT_MINI_LOAD)
+    st.session_state.setdefault('max_parallel_workers_long_line', DefaultConfig.MAX_PARALLEL_WORKERS_LONG_LINE)
+    st.session_state.setdefault('max_parallel_workers_mini_load', DefaultConfig.MAX_PARALLEL_WORKERS_MINI_LOAD)
     
     # Cost rates
-    st.session_state.setdefault('unicef_rate_shift_1', 12.5)
-    st.session_state.setdefault('unicef_rate_shift_2', 15.0)
-    st.session_state.setdefault('unicef_rate_shift_3', 18.75)
-    st.session_state.setdefault('humanizer_rate_shift_1', 10.0)
-    st.session_state.setdefault('humanizer_rate_shift_2', 12.0)
-    st.session_state.setdefault('humanizer_rate_shift_3', 15.0)
+    st.session_state.setdefault('unicef_rate_shift_1', DefaultConfig.UNICEF_RATE_SHIFT_1)
+    st.session_state.setdefault('unicef_rate_shift_2', DefaultConfig.UNICEF_RATE_SHIFT_2)
+    st.session_state.setdefault('unicef_rate_shift_3', DefaultConfig.UNICEF_RATE_SHIFT_3)
+    st.session_state.setdefault('humanizer_rate_shift_1', DefaultConfig.HUMANIZER_RATE_SHIFT_1)
+    st.session_state.setdefault('humanizer_rate_shift_2', DefaultConfig.HUMANIZER_RATE_SHIFT_2)
+    st.session_state.setdefault('humanizer_rate_shift_3', DefaultConfig.HUMANIZER_RATE_SHIFT_3)
     
     # Data selection
     st.session_state.setdefault('selected_employee_types', ["UNICEF Fixed term", "Humanizer"])
-    st.session_state.setdefault('selected_shifts', [1, 3])
-    st.session_state.setdefault('selected_lines', [6, 7])
+    st.session_state.setdefault('selected_shifts', [ShiftType.REGULAR, ShiftType.OVERTIME])
+    st.session_state.setdefault('selected_lines', [LineType.LONG_LINE, LineType.MINI_LOAD])
 
 def render_schedule_config():
     """Render schedule configuration section"""
@@ -303,9 +308,10 @@ def render_schedule_config():
     col1, col2 = st.columns(2)
     
     with col1:
-        st.session_state.start_date = st.date_input(
+        st.date_input(
             "Start Date",
-            value=st.session_state.get('start_date', datetime.date(2025, 7, 7)),
+            value=datetime.date(2025, 7, 7),
+            key='start_date',
             help="Exact start date to filter demand data - will only use orders that start on this specific date"
         )
     
@@ -316,12 +322,13 @@ def render_schedule_config():
     # Evening shift configuration
     st.subheader("🌙 Evening Shift Configuration")
     
-    st.session_state.evening_shift_mode = st.selectbox(
+    shift_mode_options = ['normal', 'activate_evening', 'always_available']
+    
+    st.selectbox(
         "Evening Shift Mode",
-        options=['normal', 'activate_evening', 'always_available'],
-        index=['normal', 'activate_evening', 'always_available'].index(
-            st.session_state.get('evening_shift_mode', 'normal')
-        ),
+        options=shift_mode_options,
+        index=shift_mode_options.index(DefaultConfig.EVENING_SHIFT_MODE),
+        key='evening_shift_mode',
         help="""
         - **Normal**: Only regular shift (1) and overtime shift (3)
         - **Activate Evening**: Allow evening shift (2) when demand is high
@@ -329,12 +336,13 @@ def render_schedule_config():
         """
     )
     
-    if st.session_state.get('evening_shift_mode') == 'activate_evening':
-        st.session_state.evening_shift_threshold = st.slider(
+    if st.session_state.evening_shift_mode == 'activate_evening':
+        st.slider(
             "Evening Shift Activation Threshold",
             min_value=0.1,
             max_value=1.0,
-            value=st.session_state.get('evening_shift_threshold', 0.9),
+            value=DefaultConfig.EVENING_SHIFT_DEMAND_THRESHOLD,
+            key='evening_shift_threshold',
             step=0.1,
             help="Activate evening shift if regular+overtime capacity < threshold of demand"
         )
@@ -344,12 +352,13 @@ def render_workforce_config():
     st.header("👥 Workforce Configuration")
     
     # Fixed staff constraint mode
-    st.session_state.fixed_staff_mode = st.selectbox(
+    staff_mode_options = ['mandatory', 'available', 'priority', 'none']
+    
+    st.selectbox(
         "Fixed Staff Constraint Mode",
-        options=['mandatory', 'available', 'priority', 'none'],
-        index=['mandatory', 'available', 'priority', 'none'].index(
-            st.session_state.get('fixed_staff_mode', 'priority')
-        ),
+        options=staff_mode_options,
+        index=staff_mode_options.index(DefaultConfig.FIXED_STAFF_MODE),
+        key='fixed_staff_mode',
         help="""
         - **Mandatory**: Forces all fixed staff to work full hours every day
         - **Available**: Staff available up to limits but not forced
@@ -364,73 +373,80 @@ def render_workforce_config():
     col1, col2 = st.columns(2)
     
     with col1:
-        st.session_state.max_unicef_per_day = st.number_input(
+        st.number_input(
             "Max UNICEF Fixed Term per Day",
             min_value=1,
             max_value=50,
-            value=st.session_state.get('max_unicef_per_day', 8),
+            value=DefaultConfig.MAX_UNICEF_PER_DAY,
+            key='max_unicef_per_day',
             help="Maximum number of UNICEF fixed term employees per day"
         )
     
     with col2:
-        st.session_state.max_humanizer_per_day = st.number_input(
+        st.number_input(
             "Max Humanizer per Day",
             min_value=1,
             max_value=50,
-            value=st.session_state.get('max_humanizer_per_day', 10),
+            value=DefaultConfig.MAX_HUMANIZER_PER_DAY,
+            key='max_humanizer_per_day',
             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(
+    st.number_input(
         "Fixed Minimum UNICEF per Day",
         min_value=0,
         max_value=20,
-        value=st.session_state.get('fixed_min_unicef_per_day', 5),
+        value=DefaultConfig.FIXED_MIN_UNICEF_PER_DAY,
+        key='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")
     
-    st.session_state.max_hour_per_person_per_day = st.number_input(
+    st.number_input(
         "Max Hours per Person per Day",
         min_value=1,
         max_value=24,
-        value=st.session_state.get('max_hour_per_person_per_day', 14),
+        value=DefaultConfig.MAX_HOUR_PER_PERSON_PER_DAY,
+        key='max_hour_per_person_per_day',
         help="Legal maximum working hours per person per day"
     )
     
     col1, col2, col3 = st.columns(3)
     
     with col1:
-        st.session_state.max_hours_shift_1 = st.number_input(
+        st.number_input(
             "Max Hours - Shift 1 (Regular)",
             min_value=1.0,
             max_value=12.0,
-            value=float(st.session_state.get('max_hours_shift_1', 9.0)),
+            value=float(DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.REGULAR]),
+            key='max_hours_shift_1',
             step=0.5,
             help="Maximum hours per person for regular shift"
         )
     
     with col2:
-        st.session_state.max_hours_shift_2 = st.number_input(
+        st.number_input(
             "Max Hours - Shift 2 (Evening)",
             min_value=1.0,
             max_value=12.0,
-            value=float(st.session_state.get('max_hours_shift_2', 7.0)),
+            value=float(DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.EVENING]),
+            key='max_hours_shift_2',
             step=0.5,
             help="Maximum hours per person for evening shift"
         )
     
     with col3:
-        st.session_state.max_hours_shift_3 = st.number_input(
+        st.number_input(
             "Max Hours - Shift 3 (Overtime)",
             min_value=1.0,
             max_value=12.0,
-            value=float(st.session_state.get('max_hours_shift_3', 4.0)),
+            value=float(DefaultConfig.MAX_HOUR_PER_SHIFT_PER_PERSON[ShiftType.OVERTIME]),
+            key='max_hours_shift_3',
             step=0.5,
             help="Maximum hours per person for overtime shift"
         )
@@ -445,36 +461,40 @@ def render_operations_config():
     col1, col2 = st.columns(2)
     
     with col1:
-        st.session_state.line_count_long_line = st.number_input(
+        st.number_input(
             "Number of Long Lines",
             min_value=1,
             max_value=20,
-            value=st.session_state.get('line_count_long_line', 3),
+            value=DefaultConfig.LINE_COUNT_LONG_LINE,
+            key='line_count_long_line',
             help="Number of long line production lines available"
         )
         
-        st.session_state.max_parallel_workers_long_line = st.number_input(
+        st.number_input(
             "Max Workers per Long Line",
             min_value=1,
             max_value=50,
-            value=st.session_state.get('max_parallel_workers_long_line', 7),
+            value=DefaultConfig.MAX_PARALLEL_WORKERS_LONG_LINE,
+            key='max_parallel_workers_long_line',
             help="Maximum number of workers that can work simultaneously on a long line"
         )
     
     with col2:
-        st.session_state.line_count_mini_load = st.number_input(
+        st.number_input(
             "Number of Mini Load Lines",
             min_value=1,
             max_value=20,
-            value=st.session_state.get('line_count_mini_load', 2),
+            value=DefaultConfig.LINE_COUNT_MINI_LOAD,
+            key='line_count_mini_load',
             help="Number of mini load production lines available"
         )
         
-        st.session_state.max_parallel_workers_mini_load = st.number_input(
+        st.number_input(
             "Max Workers per Mini Load Line",
             min_value=1,
             max_value=50,
-            value=st.session_state.get('max_parallel_workers_mini_load', 5),
+            value=DefaultConfig.MAX_PARALLEL_WORKERS_MINI_LOAD,
+            key='max_parallel_workers_mini_load',
             help="Maximum number of workers that can work simultaneously on a mini load line"
         )
 
@@ -493,27 +513,32 @@ def render_cost_config():
     
     col1, col2, col3 = st.columns(3)
     
+    payment_options = ['bulk', 'partial']
+    
     with col1:
-        st.session_state.payment_mode_shift_1 = st.selectbox(
+        st.selectbox(
             "Shift 1 (Regular) Payment",
-            options=['bulk', 'partial'],
-            index=0 if st.session_state.get('payment_mode_shift_1', 'bulk') == 'bulk' else 1,
+            options=payment_options,
+            index=payment_options.index(DefaultConfig.PAYMENT_MODE_CONFIG[ShiftType.REGULAR]),
+            key='payment_mode_shift_1',
             help="Payment mode for regular shift"
         )
     
     with col2:
-        st.session_state.payment_mode_shift_2 = st.selectbox(
+        st.selectbox(
             "Shift 2 (Evening) Payment",
-            options=['bulk', 'partial'],
-            index=0 if st.session_state.get('payment_mode_shift_2', 'bulk') == 'bulk' else 1,
+            options=payment_options,
+            index=payment_options.index(DefaultConfig.PAYMENT_MODE_CONFIG[ShiftType.EVENING]),
+            key='payment_mode_shift_2',
             help="Payment mode for evening shift"
         )
     
     with col3:
-        st.session_state.payment_mode_shift_3 = st.selectbox(
+        st.selectbox(
             "Shift 3 (Overtime) Payment",
-            options=['bulk', 'partial'],
-            index=0 if st.session_state.get('payment_mode_shift_3', 'partial') == 'bulk' else 1,
+            options=payment_options,
+            index=payment_options.index(DefaultConfig.PAYMENT_MODE_CONFIG[ShiftType.OVERTIME]),
+            key='payment_mode_shift_3',
             help="Payment mode for overtime shift"
         )
     
@@ -524,33 +549,36 @@ def render_cost_config():
     col1, col2, col3 = st.columns(3)
     
     with col1:
-        st.session_state.unicef_rate_shift_1 = st.number_input(
+        st.number_input(
             "Shift 1 (Regular) - UNICEF",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.get('unicef_rate_shift_1', 12.5)),
+            value=float(DefaultConfig.UNICEF_RATE_SHIFT_1),
+            key='unicef_rate_shift_1',
             step=0.01,
             format="%.2f",
             help="Hourly rate for UNICEF Fixed Term staff during regular shift"
         )
     
     with col2:
-        st.session_state.unicef_rate_shift_2 = st.number_input(
+        st.number_input(
             "Shift 2 (Evening) - UNICEF",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.get('unicef_rate_shift_2', 15.0)),
+            value=float(DefaultConfig.UNICEF_RATE_SHIFT_2),
+            key='unicef_rate_shift_2',
             step=0.01,
             format="%.2f",
             help="Hourly rate for UNICEF Fixed Term staff during evening shift"
         )
     
     with col3:
-        st.session_state.unicef_rate_shift_3 = st.number_input(
+        st.number_input(
             "Shift 3 (Overtime) - UNICEF",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.get('unicef_rate_shift_3', 18.75)),
+            value=float(DefaultConfig.UNICEF_RATE_SHIFT_3),
+            key='unicef_rate_shift_3',
             step=0.01,
             format="%.2f",
             help="Hourly rate for UNICEF Fixed Term staff during overtime shift"
@@ -560,33 +588,36 @@ def render_cost_config():
     col1, col2, col3 = st.columns(3)
     
     with col1:
-        st.session_state.humanizer_rate_shift_1 = st.number_input(
+        st.number_input(
             "Shift 1 (Regular) - Humanizer",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.get('humanizer_rate_shift_1', 10.0)),
+            value=float(DefaultConfig.HUMANIZER_RATE_SHIFT_1),
+            key='humanizer_rate_shift_1',
             step=0.01,
             format="%.2f",
             help="Hourly rate for Humanizer staff during regular shift"
         )
     
     with col2:
-        st.session_state.humanizer_rate_shift_2 = st.number_input(
+        st.number_input(
             "Shift 2 (Evening) - Humanizer",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.get('humanizer_rate_shift_2', 12.0)),
+            value=float(DefaultConfig.HUMANIZER_RATE_SHIFT_2),
+            key='humanizer_rate_shift_2',
             step=0.01,
             format="%.2f",
             help="Hourly rate for Humanizer staff during evening shift"
         )
     
     with col3:
-        st.session_state.humanizer_rate_shift_3 = st.number_input(
+        st.number_input(
             "Shift 3 (Overtime) - Humanizer",
             min_value=0.0,
             max_value=200.0,
-            value=float(st.session_state.get('humanizer_rate_shift_3', 15.0)),
+            value=float(DefaultConfig.HUMANIZER_RATE_SHIFT_3),
+            key='humanizer_rate_shift_3',
             step=0.01,
             format="%.2f",
             help="Hourly rate for Humanizer staff during overtime shift"
@@ -602,13 +633,10 @@ def render_data_selection_config():
     st.subheader("👥 Employee Types")
     available_employee_types = ["UNICEF Fixed term", "Humanizer"]
     
-    if 'selected_employee_types' not in st.session_state:
-        st.session_state.selected_employee_types = available_employee_types
-    
     selected_employee_types = st.multiselect(
         "Select Employee Types to Include",
         available_employee_types,
-        default=st.session_state.get('selected_employee_types', available_employee_types),
+        default=st.session_state.selected_employee_types,
         help="Choose which employee types to include in the optimization"
     )
     st.session_state.selected_employee_types = selected_employee_types
@@ -618,13 +646,10 @@ def render_data_selection_config():
     available_shifts = list(optimization_config.shift_code_to_name().keys())
     shift_names = optimization_config.shift_code_to_name()
     
-    if 'selected_shifts' not in st.session_state:
-        st.session_state.selected_shifts = available_shifts
-    
     selected_shifts = st.multiselect(
         "Select Shifts to Include",
         available_shifts,
-        default=st.session_state.get('selected_shifts', available_shifts),
+        default=st.session_state.selected_shifts,
         format_func=lambda x: f"Shift {x} ({shift_names[x]})",
         help="Choose which shifts to include in the optimization"
     )
@@ -635,13 +660,10 @@ def render_data_selection_config():
     available_lines = list(optimization_config.line_code_to_name().keys())
     line_names = optimization_config.line_code_to_name()
     
-    if 'selected_lines' not in st.session_state:
-        st.session_state.selected_lines = available_lines
-    
     selected_lines = st.multiselect(
         "Select Production Lines to Include",
         available_lines,
-        default=st.session_state.get('selected_lines', available_lines),
+        default=st.session_state.selected_lines,
         format_func=lambda x: f"Line {x} ({line_names[x]})",
         help="Choose which production lines to include in the optimization"
     )
@@ -982,9 +1004,11 @@ def clear_all_cache_and_results():
     
     st.info("🧹 Clearing all cached data and previous results...")
     
-    # 1. Clear all optimization-related session state
+    # Clear optimization cache using the dedicated function
+    clear_optimization_cache()
+    
+    # Clear additional optimization-related session state
     keys_to_clear = [
-        'optimization_results',
         'demand_dictionary',
         'kit_hierarchy_data',
         'team_requirements'
@@ -1064,11 +1088,12 @@ def run_optimization():
         st.info(f"👥 Max UNICEF/day: {st.session_state.max_unicef_per_day}, Max Humanizer/day: {st.session_state.max_humanizer_per_day}")
         
         # Import and run the optimization (after clearing)
-        from src.models.optimizer_real import run_optimization_for_week
+        from src.models.optimizer_real import Optimizer
         
-        # Run the optimization
+        # Run the optimization using Optimizer class
         with st.spinner('Optimizing workforce schedule...'):
-            results = run_optimization_for_week()
+            optimizer = Optimizer()
+            results = optimizer.run_optimization()
         
         if results is None:
             st.error("❌ Optimization failed! The problem may be infeasible with current settings.")
@@ -1083,8 +1108,20 @@ def run_optimization():
         st.rerun()  # Refresh to show results
         
     except Exception as e:
+        import traceback
         st.error(f"❌ Error during optimization: {str(e)}")
         st.error("Please check your settings and data files.")
+        
+        # Show detailed traceback in expander
+        with st.expander("🔍 Show detailed error traceback"):
+            st.code(traceback.format_exc())
+        
+        # Also print to console for debugging
+        print("\n" + "="*60)
+        print("❌ OPTIMIZATION ERROR - FULL TRACEBACK:")
+        print("="*60)
+        traceback.print_exc()
+        print("="*60)
 
 def check_critical_data_issues():
     """