Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py
-# @title Beer Game Final Version (v4.15 - Fixed Unpacking Error)
+# @title Beer Game Final Version (v4.16 - Corrected 3-Week Lead Time Logic)
 
 # -----------------------------------------------------------------------------
 # 1. Import Libraries
@@ -31,7 +31,7 @@ WEEKS = 24
 INITIAL_INVENTORY = 12
 INITIAL_BACKLOG = 0
 ORDER_PASSING_DELAY = 1
-SHIPPING_DELAY = 2 # General shipping delay
+SHIPPING_DELAY = 2 # General shipping delay (R->W, W->D)
 FACTORY_LEAD_TIME = 1
 FACTORY_SHIPPING_DELAY = 1 # Specific delay from Factory to Distributor
 HOLDING_COST = 0.5
@@ -63,6 +63,7 @@ else:
 def get_customer_demand(week: int) -> int:
     return 4 if week <= 4 else 8
 
+# =============== MODIFIED FUNCTION (Corrected Initialization) ===============
 def init_game_state(llm_personality: str, info_sharing: str):
     roles = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     human_role = "Distributor" # Role is fixed
@@ -72,10 +73,14 @@ def init_game_state(llm_personality: str, info_sharing: str):
         'game_running': True, 'participant_id': participant_id, 'week': 1,
         'human_role': human_role, 'llm_personality': llm_personality,
         'info_sharing': info_sharing, 'logs': [], 'echelons': {},
+        # Pipeline now needs to cover ORDER_PASSING_DELAY + FACTORY_LEAD_TIME
         'factory_production_pipeline': deque([0] * FACTORY_LEAD_TIME, maxlen=FACTORY_LEAD_TIME),
+        'distributor_order_pipeline': deque([0] * ORDER_PASSING_DELAY, maxlen=ORDER_PASSING_DELAY), # For D -> F order passing
+        'wholesaler_order_pipeline': deque([0] * ORDER_PASSING_DELAY, maxlen=ORDER_PASSING_DELAY), # For W -> D order passing
+        'retailer_order_pipeline': deque([0] * ORDER_PASSING_DELAY, maxlen=ORDER_PASSING_DELAY), # For R -> W order passing
         'decision_step': 'initial_order',
         'human_initial_order': None,
-        'last_week_orders': {name: 4 for name in roles} # Seed initial orders/production for week 1
+        # No need for last_week_orders anymore
     }
 
     for i, name in enumerate(roles):
@@ -83,21 +88,21 @@ def init_game_state(llm_personality: str, info_sharing: str):
         downstream = roles[i - 1] if i - 1 >= 0 else None
 
         if name == "Distributor": shipping_weeks = FACTORY_SHIPPING_DELAY
-        elif name == "Factory": shipping_weeks = 0
-        else: shipping_weeks = SHIPPING_DELAY
+        elif name == "Factory": shipping_weeks = 0 # Factory produces, doesn't receive shipments
+        else: shipping_weeks = SHIPPING_DELAY # Retailer/Wholesaler use general delay
 
-        # 'inventory' and 'backlog' now consistently represent END-OF-WEEK state
         st.session_state.game_state['echelons'][name] = {
             'name': name,
-            'inventory': INITIAL_INVENTORY, # End-of-week state (used as opening state for next week)
-            'backlog': INITIAL_BACKLOG,     # End-of-week state (used as opening state for next week)
-            'incoming_shipments': deque([0] * shipping_weeks, maxlen=shipping_weeks),
+            'inventory': INITIAL_INVENTORY, # End-of-week state
+            'backlog': INITIAL_BACKLOG,     # End-of-week state
+            'incoming_shipments': deque([0] * shipping_weeks, maxlen=shipping_weeks), # Represents only SHIPPING delay
             'incoming_order': 0, # Order received THIS week
             'order_placed': 0,   # Order placed THIS week
             'shipment_sent': 0,  # Shipment sent THIS week
             'weekly_cost': 0, 'total_cost': 0, 'upstream_name': upstream, 'downstream_name': downstream,
         }
     st.info(f"New game started! AI Mode: **{llm_personality} / {info_sharing}**. You are playing as the: **{human_role}**.")
+# ==============================================================================
 
 def get_llm_order_decision(prompt: str, echelon_name: str) -> (int, str):
     # This function remains correct.
@@ -122,20 +127,34 @@ def get_llm_order_decision(prompt: str, echelon_name: str) -> (int, str):
             st.error(f"API call failed for {echelon_name}: {e}. Defaulting to 8.")
             return 8, f"API_ERROR: {e}"
 
-# =============== MODIFIED FUNCTION (Prompt uses state AFTER arrivals/orders) ===============
+# =============== MODIFIED FUNCTION (Prompt adjusted for new pipeline view) ===============
 def get_llm_prompt(echelon_state_after_arrivals: dict, week: int, llm_personality: str, info_sharing: str, all_echelons_state_after_arrivals: dict) -> str:
     """Generates the prompt for the LLM based on the game scenario.
        Uses the state AFTER arrivals and new orders are processed, as this is the decision point."""
+
     e_state = echelon_state_after_arrivals # Use the passed-in state for prompts
+
+    # Base Info reflects state before shipping
     base_info = f"Your Current Status at the **{e_state['name']}** for **Week {week}** (Before Shipping):\n- On-hand inventory: {e_state['inventory']} units.\n- Backlog (total unfilled orders): {e_state['backlog']} units.\n- Incoming order this week (just received): {e_state['incoming_order']} units.\n"
+
     if e_state['name'] == 'Factory':
         task_word = "production quantity"
-        # Factory needs access to the global pipeline state
-        base_info += f"- Production pipeline (completing in future weeks): {list(st.session_state.game_state['factory_production_pipeline'])}"
+        # Factory prompt needs its view of the production pipeline
+        base_info += f"- Your Production Pipeline (completing next week onwards): {list(st.session_state.game_state['factory_production_pipeline'])}"
     else:
         task_word = "order quantity"
-        # Non-factory prompt needs its incoming shipments queue
-        base_info += f"- Shipments on the way to you (arriving next week and later): {list(e_state['incoming_shipments'])}"
+        # Others need their incoming shipments and orders placed but not yet received by supplier
+        base_info += f"- Shipments In Transit To You (arriving next week onwards): {list(e_state['incoming_shipments'])}\n"
+        # Show orders placed but not yet received by supplier (1 week delay)
+        if e_state['name'] == 'Distributor':
+            orders_in_transit = list(st.session_state.game_state['distributor_order_pipeline'])
+        elif e_state['name'] == 'Wholesaler':
+            orders_in_transit = list(st.session_state.game_state['wholesaler_order_pipeline'])
+        elif e_state['name'] == 'Retailer':
+            orders_in_transit = list(st.session_state.game_state['retailer_order_pipeline'])
+        else: orders_in_transit = []
+        base_info += f"- Orders You Placed (in transit to supplier): {orders_in_transit}"
+
 
     # --- Perfect Rational ---
     if llm_personality == 'perfect_rational' and info_sharing == 'full':
@@ -146,13 +165,19 @@ def get_llm_prompt(echelon_state_after_arrivals: dict, week: int, llm_personalit
         safety_stock = 4
         target_inventory_level = (stable_demand * total_lead_time) + safety_stock
 
-        # Calculate Inventory Position based on state AFTER arrivals/orders
+        # Calculate Inventory Position based on state AFTER arrivals/orders AND pipelines
         if e_state['name'] == 'Factory':
-            inv_pos_components = f"(Current Inv: {e_state['inventory']} - Current Backlog: {e_state['backlog']} + In_Production: {sum(st.session_state.game_state['factory_production_pipeline'])})"
+            # IP = Inv - Backlog + In Production
             inventory_position = (e_state['inventory'] - e_state['backlog'] + sum(st.session_state.game_state['factory_production_pipeline']))
+            inv_pos_components = f"(Inv={e_state['inventory']} - Backlog={e_state['backlog']} + InProd={sum(st.session_state.game_state['factory_production_pipeline'])})"
         else:
-            inv_pos_components = f"(Current Inv: {e_state['inventory']} - Current Backlog: {e_state['backlog']} + In_Transit: {sum(e_state['incoming_shipments'])})"
-            inventory_position = (e_state['inventory'] - e_state['backlog'] + sum(e_state['incoming_shipments']))
+            # IP = Inv - Backlog + In Transit Shipments + Orders Placed but not yet received by supplier
+            if e_state['name'] == 'Distributor': orders_in_transit_sum = sum(st.session_state.game_state['distributor_order_pipeline'])
+            elif e_state['name'] == 'Wholesaler': orders_in_transit_sum = sum(st.session_state.game_state['wholesaler_order_pipeline'])
+            elif e_state['name'] == 'Retailer': orders_in_transit_sum = sum(st.session_state.game_state['retailer_order_pipeline'])
+            else: orders_in_transit_sum = 0
+            inventory_position = (e_state['inventory'] - e_state['backlog'] + sum(e_state['incoming_shipments']) + orders_in_transit_sum)
+            inv_pos_components = f"(Inv={e_state['inventory']} - Backlog={e_state['backlog']} + InTransitShip={sum(e_state['incoming_shipments'])} + InTransitOrder={orders_in_transit_sum})"
 
         optimal_order = max(0, int(target_inventory_level - inventory_position))
 
@@ -160,26 +185,28 @@ def get_llm_prompt(echelon_state_after_arrivals: dict, week: int, llm_personalit
 
     elif llm_personality == 'perfect_rational' and info_sharing == 'local':
         safety_stock = 4; anchor_demand = e_state['incoming_order']
-
-        # Use state AFTER arrivals/orders for inventory correction calculation
         inventory_correction = safety_stock - (e_state['inventory'] - e_state['backlog'])
 
         if e_state['name'] == 'Factory':
             supply_line = sum(st.session_state.game_state['factory_production_pipeline'])
             supply_line_desc = "In Production"
         else:
-            supply_line = sum(e_state['incoming_shipments'])
-            supply_line_desc = "In Transit Shipments"
+            # Supply line includes shipments AND orders in transit
+            if e_state['name'] == 'Distributor': orders_in_transit_sum = sum(st.session_state.game_state['distributor_order_pipeline'])
+            elif e_state['name'] == 'Wholesaler': orders_in_transit_sum = sum(st.session_state.game_state['wholesaler_order_pipeline'])
+            elif e_state['name'] == 'Retailer': orders_in_transit_sum = sum(st.session_state.game_state['retailer_order_pipeline'])
+            else: orders_in_transit_sum = 0
+            supply_line = sum(e_state['incoming_shipments']) + orders_in_transit_sum
+            supply_line_desc = "Supply Line (In Transit Shipments + Orders)"
 
         calculated_order = anchor_demand + inventory_correction - supply_line
         rational_local_order = max(0, int(calculated_order))
 
-        return f"**You are a perfectly rational supply chain AI with ONLY LOCAL information.**\nYou must use a logical heuristic to make a stable decision. A proven method is \"Anchoring and Adjustment\".\n\n{base_info}\n\n**Rational Calculation (Anchoring & Adjustment):**\n1.  **Anchor on Demand:** Your best guess for future demand is your last incoming order: **{anchor_demand} units**.\n2.  **Adjust for Inventory:** You want to hold a safety stock of {safety_stock} units. Your current stock (before shipping) is {e_state['inventory'] - e_state['backlog']}. You need to order an extra **{inventory_correction} units** to correct this.\n3.  **Account for {supply_line_desc}:** You already have **{supply_line} units** being processed. These should be subtracted from your new order.\n\n**Final Calculation:**\n* Decision = (Anchor Demand) + (Inventory Adjustment) - ({supply_line_desc})\n* Decision = {anchor_demand} + {inventory_correction} - {supply_line} = **{rational_local_order} units**.\n**Your Task:** Confirm this locally rational {task_word}. Respond with a single integer."
+        return f"**You are a perfectly rational supply chain AI with ONLY LOCAL information.**\nYou must use a logical heuristic to make a stable decision. A proven method is \"Anchoring and Adjustment\".\n\n{base_info}\n\n**Rational Calculation (Anchoring & Adjustment):**\n1.  **Anchor on Demand:** Your best guess for future demand is your last incoming order: **{anchor_demand} units**.\n2.  **Adjust for Inventory:** You want to hold a safety stock of {safety_stock} units. Your current stock (before shipping) is {e_state['inventory'] - e_state['backlog']}. You need to order an extra **{inventory_correction} units** to correct this.\n3.  **Account for {supply_line_desc}:** You already have **{supply_line} units** being processed (either shipping or orders in transit). These should be subtracted from your new decision.\n\n**Final Calculation:**\n* Decision = (Anchor Demand) + (Inventory Adjustment) - ({supply_line_desc})\n* Decision = {anchor_demand} + {inventory_correction} - {supply_line} = **{rational_local_order} units**.\n**Your Task:** Confirm this locally rational {task_word}. Respond with a single integer."
 
     # --- Human-like ---
     elif llm_personality == 'human_like' and info_sharing == 'full':
         full_info_str = f"\n**Full Supply Chain Information (State Before Shipping):**\n- End-Customer Demand this week: {get_customer_demand(week)} units.\n"
-        # Display other players' state AFTER arrivals/orders
         for name, other_e_state in all_echelons_state_after_arrivals.items():
             if name != e_state['name']: full_info_str += f"- {name}: Inv={other_e_state['inventory']}, Backlog={other_e_state['backlog']}\n"
 
@@ -203,10 +230,9 @@ def get_llm_prompt(echelon_state_after_arrivals: dict, week: int, llm_personalit
         Your gut instinct is to panic and {task_word.split(' ')[0]} enough to ensure you are never caught with a backlog again, considering your current inventory.
         **React emotionally.** What is your knee-jerk {task_word}? Respond with a single integer.
         """
-
 # ==============================================================================
 
-# =============== CORRECTED step_game FUNCTION ===============
+# =============== CORRECTED step_game FUNCTION (Handles 3-week LT) ===============
 def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: int):
     state = st.session_state.game_state
     week, echelons, human_role = state['week'], state['echelons'], state['human_role']
@@ -215,69 +241,71 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     llm_raw_responses = {}
 
     # Store state at the very beginning of the week for logging opening balances
-    # These are the inventory/backlog values from the END of the previous week
     opening_inventories = {name: e['inventory'] for name, e in echelons.items()}
     opening_backlogs = {name: e['backlog'] for name, e in echelons.items()}
     arrived_this_week = {name: 0 for name in echelon_order} # Track arrivals for logging
 
     # --- Game Simulation Steps ---
 
-    # Step 1a: Factory Production completes
+    # Step 1a & 1b: Shipments/Production Arrive & Update Temp Inventory
+    inventory_after_arrival = {} # Store intermediate inventory state
+    # Factory production completion
     factory_state = echelons["Factory"]
     produced_units = 0
     if state['factory_production_pipeline']:
-        produced_units = state['factory_production_pipeline'].popleft()
-        # Temporarily store, don't update main state yet
-        inventory_after_production = factory_state['inventory'] + produced_units
+        produced_units = state['factory_production_pipeline'].popleft() # Pop from beginning (what was scheduled LEAST recently)
         arrived_this_week["Factory"] = produced_units
-    else:
-        inventory_after_production = factory_state['inventory']
+    inventory_after_arrival["Factory"] = factory_state['inventory'] + produced_units
 
-    # Step 1b: Shipments arrive at downstream echelons
-    inventory_after_arrival = {} # Store intermediate state
+    # Downstream shipment arrivals
     for name in ["Retailer", "Wholesaler", "Distributor"]:
         arrived_shipment = 0
         if echelons[name]['incoming_shipments']:
-            arrived_shipment = echelons[name]['incoming_shipments'].popleft()
+            arrived_shipment = echelons[name]['incoming_shipments'].popleft() # Pop from beginning
             arrived_this_week[name] = arrived_shipment
         inventory_after_arrival[name] = echelons[name]['inventory'] + arrived_shipment
-    inventory_after_arrival["Factory"] = inventory_after_production # Add factory's state
 
 
-    # Step 2: Orders arrive from downstream partners (using LAST week's placed order)
-    total_backlog_before_shipping = {} # Store intermediate state
+    # Step 2: Orders Arrive from Downstream & Update Temp Backlog
+    # Orders arrive after ORDER_PASSING_DELAY
+    total_backlog_before_shipping = {} # Store intermediate backlog state
     for name in echelon_order:
+        incoming_order_for_this_week = 0
         if name == "Retailer":
-            echelons[name]['incoming_order'] = get_customer_demand(week)
+            incoming_order_for_this_week = get_customer_demand(week)
         else:
+            # Check the correct order pipeline based on the downstream partner
             downstream_name = echelons[name]['downstream_name']
-            order_from_downstream = 0
-            if downstream_name:
-                order_from_downstream = state['last_week_orders'].get(downstream_name, 0)
-            echelons[name]['incoming_order'] = order_from_downstream
-        # Calculate the total backlog BEFORE shipping
-        total_backlog_before_shipping[name] = echelons[name]['backlog'] + echelons[name]['incoming_order']
+            if downstream_name == 'Distributor':
+                if state['distributor_order_pipeline']:
+                    incoming_order_for_this_week = state['distributor_order_pipeline'].popleft()
+            elif downstream_name == 'Wholesaler':
+                 if state['wholesaler_order_pipeline']:
+                    incoming_order_for_this_week = state['wholesaler_order_pipeline'].popleft()
+            elif downstream_name == 'Retailer':
+                 if state['retailer_order_pipeline']:
+                    incoming_order_for_this_week = state['retailer_order_pipeline'].popleft()
+
+        echelons[name]['incoming_order'] = incoming_order_for_this_week # Store for logging/display
+        total_backlog_before_shipping[name] = echelons[name]['backlog'] + incoming_order_for_this_week
+
 
     # --- Create State Snapshot for AI/Human Decision Point ---
-    # This reflects the state AFTER arrivals and new orders, BEFORE shipping
     decision_point_states = {}
     for name in echelon_order:
-         # Need to create a copy, including deque if needed for prompt
          decision_point_states[name] = {
              'name': name,
              'inventory': inventory_after_arrival[name], # Inventory available
              'backlog': total_backlog_before_shipping[name], # Total demand to meet
              'incoming_order': echelons[name]['incoming_order'], # Order received this week
-             # Pass the current state of queues for prompt generation
              'incoming_shipments': echelons[name]['incoming_shipments'].copy() if name != "Factory" else deque(),
          }
 
     # --- Step 4: Agent Decisions (Place Orders / Schedule Production) ---
-    # Agents make decisions based on the decision_point_states
     current_week_orders = {}
     for name in echelon_order:
-        e = echelons[name] # Get the main state dict to store results
-        prompt_state = decision_point_states[name] # Use the snapshot for the prompt
+        e = echelons[name]
+        prompt_state = decision_point_states[name]
 
         if name == human_role:
             order_amount, raw_resp = human_final_order, "HUMAN_FINAL_INPUT"
@@ -286,14 +314,24 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
             order_amount, raw_resp = get_llm_order_decision(prompt, name)
 
         llm_raw_responses[name] = raw_resp
-        e['order_placed'] = max(0, order_amount) # Store the decision in the main state dict
+        e['order_placed'] = max(0, order_amount)
         current_week_orders[name] = e['order_placed']
 
-    # Factory schedules production based on its 'order_placed' decision
+        # Put the order into the correct pipeline to simulate ORDER_PASSING_DELAY
+        if name == 'Distributor': state['distributor_order_pipeline'].append(e['order_placed'])
+        elif name == 'Wholesaler': state['wholesaler_order_pipeline'].append(e['order_placed'])
+        elif name == 'Retailer': state['retailer_order_pipeline'].append(e['order_placed'])
+        # Factory's 'order_placed' is its production decision
+
+
+    # Step 4b: Factory schedules production
+    # Factory's decision ('order_placed') enters the production pipeline
     state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
 
+
     # --- Step 3: Fulfill orders (Ship Beer) ---
-    # Now perform the shipping based on the inventory_after_arrival and total_backlog_before_shipping
+    # Occurs after decisions, uses inventory_after_arrival and total_backlog_before_shipping
+    units_produced_and_shipped_by_factory = 0 # Track for adding to Distributor's shipment queue
     for name in echelon_order:
         e = echelons[name]
         demand_to_meet = total_backlog_before_shipping[name]
@@ -304,47 +342,47 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
         e['inventory'] = available_inv - e['shipment_sent']
         e['backlog'] = demand_to_meet - e['shipment_sent']
 
-    # Step 3b: Place shipped items into the *end* of the downstream partner's incoming shipment queue
-    for sender_name in ["Factory", "Distributor", "Wholesaler"]:
-        sender = echelons[sender_name]
-        receiver_name = sender['downstream_name']
-        if receiver_name:
-            echelons[receiver_name]['incoming_shipments'].append(sender['shipment_sent'])
+        # If Factory, what it 'sent' was actually produced and ready for shipping delay
+        if name == "Factory":
+            units_produced_and_shipped_by_factory = e['shipment_sent']
+
+    # Step 3b: Place items shipped by Factory/Distributor/Wholesaler into appropriate shipment queues
+    # Factory -> Distributor (uses FACTORY_SHIPPING_DELAY)
+    if units_produced_and_shipped_by_factory > 0:
+        echelons['Distributor']['incoming_shipments'].append(units_produced_and_shipped_by_factory)
+    # Distributor -> Wholesaler (uses SHIPPING_DELAY)
+    if echelons['Distributor']['shipment_sent'] > 0:
+         echelons['Wholesaler']['incoming_shipments'].append(echelons['Distributor']['shipment_sent'])
+    # Wholesaler -> Retailer (uses SHIPPING_DELAY)
+    if echelons['Wholesaler']['shipment_sent'] > 0:
+         echelons['Retailer']['incoming_shipments'].append(echelons['Wholesaler']['shipment_sent'])
 
 
     # --- Calculate Costs & Log (End of Week) ---
     log_entry = {'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week, **state}
-    # These fields are nested in echelons, no need to log them top-level
-    del log_entry['echelons'], log_entry['factory_production_pipeline'], log_entry['logs'], log_entry['last_week_orders']
+    del log_entry['echelons'], log_entry['factory_production_pipeline'], log_entry['logs']
+    # Delete the specific order pipelines as well
+    for key in ['distributor_order_pipeline', 'wholesaler_order_pipeline', 'retailer_order_pipeline']:
+        if key in log_entry: del log_entry[key]
+
 
     for name in echelon_order:
         e = echelons[name]
-        # Costs are based on the END OF WEEK state
         e['weekly_cost'] = (e['inventory'] * HOLDING_COST) + (e['backlog'] * BACKLOG_COST)
         e['total_cost'] += e['weekly_cost']
 
-        # Log end-of-week internal state and decisions/events of the week
-        log_entry[f'{name}.inventory'] = e['inventory'] # End of week inventory
-        log_entry[f'{name}.backlog'] = e['backlog']     # End of week backlog
-        log_entry[f'{name}.incoming_order'] = e['incoming_order'] # Order received this week
-        log_entry[f'{name}.order_placed'] = e['order_placed'] # Decision made this week
-        log_entry[f'{name}.shipment_sent'] = e['shipment_sent'] # Shipped this week
-        log_entry[f'{name}.weekly_cost'] = e['weekly_cost'] # Cost for this week
-        log_entry[f'{name}.total_cost'] = e['total_cost'] # Cumulative cost
-        log_entry[f'{name}.llm_raw_response'] = llm_raw_responses.get(name, "")
-
-        # Log opening balances for the week
-        log_entry[f'{name}.opening_inventory'] = opening_inventories[name]
-        log_entry[f'{name}.opening_backlog'] = opening_backlogs[name]
+        log_entry[f'{name}.inventory'] = e['inventory']; log_entry[f'{name}.backlog'] = e['backlog']
+        log_entry[f'{name}.incoming_order'] = e['incoming_order']; log_entry[f'{name}.order_placed'] = e['order_placed']
+        log_entry[f'{name}.shipment_sent'] = e['shipment_sent']; log_entry[f'{name}.weekly_cost'] = e['weekly_cost']
+        log_entry[f'{name}.total_cost'] = e['total_cost']; log_entry[f'{name}.llm_raw_response'] = llm_raw_responses.get(name, "")
+        log_entry[f'{name}.opening_inventory'] = opening_inventories[name]; log_entry[f'{name}.opening_backlog'] = opening_backlogs[name]
         log_entry[f'{name}.arrived_this_week'] = arrived_this_week[name]
 
-        # Log prediction for next week's arrival/completion (based on queues AFTER this week's processing)
         if name != 'Factory':
              log_entry[f'{name}.arriving_next_week'] = list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0
         else:
              log_entry[f'{name}.production_completing_next_week'] = list(state['factory_production_pipeline'])[0] if state['factory_production_pipeline'] else 0
 
-    # Log human-specific decisions
     log_entry[f'{human_role}.initial_order'] = human_initial_order
     log_entry[f'{human_role}.ai_suggestion'] = ai_suggestion
 
@@ -353,12 +391,13 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     # --- Advance Week ---
     state['week'] += 1
     state['decision_step'] = 'initial_order'
-    state['last_week_orders'] = current_week_orders # Store current decisions for next week's Step 2
+    # 'last_week_orders' is no longer needed with pipeline approach
+    # if 'last_week_orders' in state: del state['last_week_orders']
 
     if state['week'] > WEEKS: state['game_running'] = False
-
 # ==============================================================================
 
+
 def plot_results(df: pd.DataFrame, title: str, human_role: str):
     # This function remains correct.
     fig, axes = plt.subplots(4, 1, figsize=(12, 22))
@@ -450,7 +489,7 @@ def save_logs_and_upload(state: dict):
                 st.error(f"Upload to Hugging Face failed: {e}")
 
 # -----------------------------------------------------------------------------
-# 4. Streamlit UI
+# 4. Streamlit UI (Minor adjustments for clarity)
 # -----------------------------------------------------------------------------
 st.title("🍺 The Beer Game: A Human-AI Collaboration Challenge")
 
@@ -510,7 +549,7 @@ else:
         Managing your inventory and backlog is key to minimizing costs. Here's how they work:
         * **Effective "Orders to Fill":** Each week, the total demand you need to satisfy is your `Incoming Order` for the week PLUS any `Backlog` carried over from the previous week.
         * **If you DON'T have enough inventory:**
-            * You ship **all** the inventory you have.
+            * You ship **all** the inventory you have (after receiving any arrivals for the week).
             * The remaining unfilled "Orders to Fill" becomes your **new Backlog** for next week.
             * **Backlog is cumulative!** If you start Week 10 with a backlog of 5, get an order for 8 (total needed = 13), receive 10 units, and ship those 10 units, your new backlog for Week 11 is `13 - 10 = 3`.
         * **If you DO have enough inventory:**
@@ -535,10 +574,10 @@ else:
 
         **B) Your Dashboard (What You See for Your Turn):**
         The dashboard shows your status **at the start of the week, BEFORE Steps 1, 2, and 3 happen**:
-        * `Inventory (Opening)`: Your stock **at the beginning of the week**. This is the inventory carried over from the end of last week.
+        * `Inventory (Opening)`: Your stock **at the beginning of the week**.
         * `Backlog (Opening)`: Unfilled orders **carried over from the end of last week**.
-        * `Incoming Order (This Week)`: The specific order quantity that **will arrive** from the Wholesaler *during* this week (Step 2). Use this for your planning.
-        * `Arriving Next Week`: The quantity scheduled to arrive at the start of the **next week**. Use this for your planning.
+        * `Incoming Order (This Week)`: The specific order quantity that **will arrive** from the Wholesaler *during* this week (Step 2).
+        * `Arriving Next Week`: The quantity scheduled to arrive at the start of the **next week**.
         * `Your Total Cumulative Cost`: Sum of all weekly costs up to the **end of last week**.
         * `Cost Last Week`: The specific cost incurred just **last week**.
 
@@ -567,8 +606,7 @@ else:
     elif 'game_state' in st.session_state and st.session_state.game_state.get('game_running'):
         state = st.session_state.game_state
         week, human_role, echelons, info_sharing = state['week'], state['human_role'], state['echelons'], state['info_sharing']
-        # Define echelon order for display in the UI
-        echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"]
+        echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"] # Define here for UI
 
 
         st.header(f"Week {week} / {WEEKS}")