Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py
-# @title Beer Game Final Version (v4.16 - Corrected 3-Week Lead Time Logic)
+# @title Beer Game Final Version (v4.17 - Simplified Order Logic & State Clarity - COMPLETE CODE)
 
 # -----------------------------------------------------------------------------
 # 1. Import Libraries
@@ -30,7 +30,7 @@ st.set_page_config(page_title="Beer Game: Human-AI Collaboration", layout="wide"
 WEEKS = 24
 INITIAL_INVENTORY = 12
 INITIAL_BACKLOG = 0
-ORDER_PASSING_DELAY = 1
+ORDER_PASSING_DELAY = 1 # Handled by last_week_orders
 SHIPPING_DELAY = 2 # General shipping delay (R->W, W->D)
 FACTORY_LEAD_TIME = 1
 FACTORY_SHIPPING_DELAY = 1 # Specific delay from Factory to Distributor
@@ -63,7 +63,7 @@ else:
 def get_customer_demand(week: int) -> int:
     return 4 if week <= 4 else 8
 
-# =============== MODIFIED FUNCTION (Corrected Initialization) ===============
+# =============== CORRECTED Initialization ===============
 def init_game_state(llm_personality: str, info_sharing: str):
     roles = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     human_role = "Distributor" # Role is fixed
@@ -73,14 +73,11 @@ 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,
-        # No need for last_week_orders anymore
+        # Initialize last week's orders to 0, representing the state before week 1
+        'last_week_orders': {name: 0 for name in roles}
     }
 
     for i, name in enumerate(roles):
@@ -121,63 +118,50 @@ def get_llm_order_decision(prompt: str, echelon_name: str) -> (int, str):
             raw_text = response.choices[0].message.content.strip()
             match = re.search(r'\d+', raw_text)
             if match: return int(match.group(0)), raw_text
-            st.warning(f"LLM for {echelon_name} did not return a valid number. Defaulting to 8. Raw Response: '{raw_text}'")
-            return 8, raw_text # Default if no number found
+            st.warning(f"LLM for {echelon_name} did not return a valid number. Defaulting to 4. Raw Response: '{raw_text}'")
+            return 4, raw_text # Default to 4 if no number found
         except Exception as e:
-            st.error(f"API call failed for {echelon_name}: {e}. Defaulting to 8.")
-            return 8, f"API_ERROR: {e}"
+            st.error(f"API call failed for {echelon_name}: {e}. Defaulting to 4.")
+            return 4, f"API_ERROR: {e}"
 
-# =============== 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:
+# =============== MODIFIED FUNCTION (Prompt uses simplified state) ===============
+def get_llm_prompt(echelon_state_decision_point: dict, week: int, llm_personality: str, info_sharing: str, all_echelons_state_decision_point: 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."""
+       Uses the state AFTER arrivals and new orders are processed (decision point)."""
 
-    e_state = echelon_state_after_arrivals # Use the passed-in state for prompts
+    e_state = echelon_state_decision_point
 
     # 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 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"
-        # 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}"
-
+        base_info += f"- Shipments In Transit To You (arriving next week onwards): {list(e_state['incoming_shipments'])}" # This queue length matches shipping delay
 
     # --- Perfect Rational ---
     if llm_personality == 'perfect_rational' and info_sharing == 'full':
         stable_demand = 8
+        # Lead time calculation remains the same for target inventory
         if e_state['name'] == 'Factory': total_lead_time = FACTORY_LEAD_TIME
         elif e_state['name'] == 'Distributor': total_lead_time = ORDER_PASSING_DELAY + FACTORY_LEAD_TIME + FACTORY_SHIPPING_DELAY
         else: total_lead_time = ORDER_PASSING_DELAY + SHIPPING_DELAY
         safety_stock = 4
         target_inventory_level = (stable_demand * total_lead_time) + safety_stock
 
-        # Calculate Inventory Position based on state AFTER arrivals/orders AND pipelines
+        # Calculate Inventory Position based on decision point state + relevant pipelines
         if e_state['name'] == 'Factory':
             # 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:
-            # 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})"
+            # IP = Inv - Backlog + In Transit Shipments + Order Placed Last Week (in transit to supplier)
+            order_in_transit_to_supplier = st.session_state.game_state['last_week_orders'].get(e_state['name'], 0)
+
+            inventory_position = (e_state['inventory'] - e_state['backlog'] + sum(e_state['incoming_shipments']) + order_in_transit_to_supplier)
+            inv_pos_components = f"(Inv={e_state['inventory']} - Backlog={e_state['backlog']} + InTransitShip={sum(e_state['incoming_shipments'])} + OrderToSupplier={order_in_transit_to_supplier})"
 
         optimal_order = max(0, int(target_inventory_level - inventory_position))
 
@@ -191,23 +175,20 @@ def get_llm_prompt(echelon_state_after_arrivals: dict, week: int, llm_personalit
             supply_line = sum(st.session_state.game_state['factory_production_pipeline'])
             supply_line_desc = "In Production"
         else:
-            # 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)"
+            # Supply line includes shipments AND the order placed last week
+            order_in_transit_to_supplier = st.session_state.game_state['last_week_orders'].get(e_state['name'], 0)
+            supply_line = sum(e_state['incoming_shipments']) + order_in_transit_to_supplier
+            supply_line_desc = "Supply Line (In Transit Shipments + Order To Supplier)"
 
         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 (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."
+        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 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"
-        for name, other_e_state in all_echelons_state_after_arrivals.items():
+        for name, other_e_state in all_echelons_state_decision_point.items():
             if name != e_state['name']: full_info_str += f"- {name}: Inv={other_e_state['inventory']}, Backlog={other_e_state['backlog']}\n"
 
         return f"""
@@ -232,7 +213,7 @@ def get_llm_prompt(echelon_state_after_arrivals: dict, week: int, llm_personalit
         """
 # ==============================================================================
 
-# =============== CORRECTED step_game FUNCTION (Handles 3-week LT) ===============
+# =============== CORRECTED step_game FUNCTION (Simplified Order Logic) ===============
 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']
@@ -240,7 +221,7 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"] # Defined here
     llm_raw_responses = {}
 
-    # Store state at the very beginning of the week for logging opening balances
+    # Store state at the very beginning of the week (End of last 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
@@ -253,7 +234,7 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     factory_state = echelons["Factory"]
     produced_units = 0
     if state['factory_production_pipeline']:
-        produced_units = state['factory_production_pipeline'].popleft() # Pop from beginning (what was scheduled LEAST recently)
+        produced_units = state['factory_production_pipeline'].popleft() # Pop completed production
         arrived_this_week["Factory"] = produced_units
     inventory_after_arrival["Factory"] = factory_state['inventory'] + produced_units
 
@@ -261,51 +242,46 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     for name in ["Retailer", "Wholesaler", "Distributor"]:
         arrived_shipment = 0
         if echelons[name]['incoming_shipments']:
-            arrived_shipment = echelons[name]['incoming_shipments'].popleft() # Pop from beginning
+            arrived_shipment = echelons[name]['incoming_shipments'].popleft() # Pop arrived shipment
             arrived_this_week[name] = arrived_shipment
         inventory_after_arrival[name] = echelons[name]['inventory'] + arrived_shipment
 
-
     # Step 2: Orders Arrive from Downstream & Update Temp Backlog
-    # Orders arrive after ORDER_PASSING_DELAY
+    # Orders arrive based on LAST WEEK's placed order (Delay = 1)
     total_backlog_before_shipping = {} # Store intermediate backlog state
     for name in echelon_order:
         incoming_order_for_this_week = 0
         if name == "Retailer":
             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']
-            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
+            if downstream_name:
+                # Use the order placed by the downstream partner LAST week
+                incoming_order_for_this_week = state['last_week_orders'].get(downstream_name, 0)
 
+        echelons[name]['incoming_order'] = incoming_order_for_this_week # Store for logging/UI this week
+        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 a copy, including DEQUEUES for prompt generation
          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]
-        prompt_state = decision_point_states[name]
+        e = echelons[name] # Get the main state dict to store results
+        prompt_state = decision_point_states[name] # Use the snapshot for the prompt
 
         if name == human_role:
             order_amount, raw_resp = human_final_order, "HUMAN_FINAL_INPUT"
@@ -314,63 +290,52 @@ 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)
-        current_week_orders[name] = e['order_placed']
+        e['order_placed'] = max(0, order_amount) # Store the decision in the main state dict
+        current_week_orders[name] = e['order_placed'] # Store for NEXT week's Step 2
 
-        # 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
+    # Factory schedules production based on its 'order_placed' decision
     state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
 
 
     # --- Step 3: Fulfill orders (Ship Beer) ---
-    # 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
+    # Uses inventory_after_arrival and total_backlog_before_shipping
+    units_shipped = {name: 0 for name in echelon_order}
     for name in echelon_order:
         e = echelons[name]
         demand_to_meet = total_backlog_before_shipping[name]
         available_inv = inventory_after_arrival[name]
 
         e['shipment_sent'] = min(available_inv, demand_to_meet)
+        units_shipped[name] = e['shipment_sent'] # Store temporarily
+
         # Update the main state dict's inventory and backlog to reflect END OF WEEK state
         e['inventory'] = available_inv - e['shipment_sent']
         e['backlog'] = demand_to_meet - e['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
+    # Step 3b: Place shipped items into the *end* of the downstream partner's incoming shipment queue
     # 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)
+    if units_shipped["Factory"] > 0:
+        echelons['Distributor']['incoming_shipments'].append(units_shipped["Factory"])
     # Distributor -> Wholesaler (uses SHIPPING_DELAY)
-    if echelons['Distributor']['shipment_sent'] > 0:
-         echelons['Wholesaler']['incoming_shipments'].append(echelons['Distributor']['shipment_sent'])
+    if units_shipped['Distributor'] > 0:
+         echelons['Wholesaler']['incoming_shipments'].append(units_shipped['Distributor'])
     # Wholesaler -> Retailer (uses SHIPPING_DELAY)
-    if echelons['Wholesaler']['shipment_sent'] > 0:
-         echelons['Retailer']['incoming_shipments'].append(echelons['Wholesaler']['shipment_sent'])
+    if units_shipped['Wholesaler'] > 0:
+         echelons['Retailer']['incoming_shipments'].append(units_shipped['Wholesaler'])
 
 
     # --- Calculate Costs & Log (End of Week) ---
     log_entry = {'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week, **state}
-    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]
-
+    # Clean up fields not suitable for direct logging
+    del log_entry['echelons'], log_entry['factory_production_pipeline'], log_entry['logs'], log_entry['last_week_orders']
 
     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']; 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']
@@ -378,11 +343,13 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
         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
 
@@ -391,8 +358,7 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     # --- Advance Week ---
     state['week'] += 1
     state['decision_step'] = 'initial_order'
-    # 'last_week_orders' is no longer needed with pipeline approach
-    # if 'last_week_orders' in state: del state['last_week_orders']
+    state['last_week_orders'] = current_week_orders # Store current decisions for next week's Step 2
 
     if state['week'] > WEEKS: state['game_running'] = False
 # ==============================================================================
@@ -438,24 +404,30 @@ def plot_results(df: pd.DataFrame, title: str, human_role: str):
     # Safely access human decision columns
     human_cols = [f'{human_role}.initial_order', f'{human_role}.ai_suggestion', f'{human_role}.order_placed']
     human_df_cols = ['week'] + [col for col in human_cols if col in df.columns]
-    human_df = df[human_df_cols].copy()
-    human_df.rename(columns={
-        f'{human_role}.initial_order': 'Your Initial Order',
-        f'{human_role}.ai_suggestion': 'AI Suggestion',
-        f'{human_role}.order_placed': 'Your Final Order'
-    }, inplace=True)
-
-    if len(human_df.columns) > 1: # Check if there's data to plot
-        human_df.plot(x='week', ax=axes[3], marker='o', linestyle='-')
-        axes[3].set_title(f'Analysis of Your ({human_role}) Decisions')
-        axes[3].set_ylabel('Order Quantity')
-        axes[3].grid(True, linestyle='--')
-        axes[3].set_xlabel('Week')
-    else:
-        axes[3].set_title(f'Analysis of Your ({human_role}) Decisions - No Data')
+
+    # Add try-except for robust plotting if columns are missing
+    try:
+        human_df = df[human_df_cols].copy()
+        human_df.rename(columns={
+            f'{human_role}.initial_order': 'Your Initial Order',
+            f'{human_role}.ai_suggestion': 'AI Suggestion',
+            f'{human_role}.order_placed': 'Your Final Order'
+        }, inplace=True)
+
+        if len(human_df.columns) > 1: # Check if there's data to plot
+            human_df.plot(x='week', ax=axes[3], marker='o', linestyle='-')
+            axes[3].set_title(f'Analysis of Your ({human_role}) Decisions')
+            axes[3].set_ylabel('Order Quantity')
+            axes[3].grid(True, linestyle='--')
+            axes[3].set_xlabel('Week')
+        else: raise ValueError("No human decision data columns found.")
+    except (KeyError, ValueError) as plot_err:
+        axes[3].set_title(f'Analysis of Your ({human_role}) Decisions - Error Plotting Data')
+        axes[3].text(0.5, 0.5, f"Error: {plot_err}", ha='center', va='center')
         axes[3].grid(True, linestyle='--')
         axes[3].set_xlabel('Week')
 
+
     plt.tight_layout(rect=[0, 0, 1, 0.96])
     return fig
 
@@ -463,33 +435,38 @@ def save_logs_and_upload(state: dict):
     # This function remains correct.
     if not state.get('logs'): return
     participant_id = state['participant_id']
-    df = pd.json_normalize(state['logs'])
-    fname = LOCAL_LOG_DIR / f"log_{participant_id}_{int(time.time())}.csv"
-
-    for col in df.columns:
-        if df[col].dtype == 'object': df[col] = df[col].astype(str)
-
-    df.to_csv(fname, index=False)
-    st.success(f"Log successfully saved locally: `{fname}`")
-    with open(fname, "rb") as f:
-        st.download_button("📥 Download Log CSV", data=f, file_name=fname.name, mime="text/csv")
-
-    if HF_TOKEN and HF_REPO_ID and hf_api:
-        with st.spinner("Uploading log to Hugging Face Hub..."):
-            try:
-                url = hf_api.upload_file(
-                    path_or_fileobj=str(fname),
-                    path_in_repo=f"logs/{fname.name}",
-                    repo_id=HF_REPO_ID,
-                    repo_type="dataset",
-                    token=HF_TOKEN
-                )
-                st.success(f"✅ Log successfully uploaded to Hugging Face! [View File]({url})")
-            except Exception as e:
-                st.error(f"Upload to Hugging Face failed: {e}")
+    try:
+        df = pd.json_normalize(state['logs'])
+        fname = LOCAL_LOG_DIR / f"log_{participant_id}_{int(time.time())}.csv"
+
+        # Convert potential object columns safely before saving
+        for col in df.select_dtypes(include=['object']).columns:
+            df[col] = df[col].astype(str)
+
+        df.to_csv(fname, index=False)
+        st.success(f"Log successfully saved locally: `{fname}`")
+        with open(fname, "rb") as f:
+            st.download_button("📥 Download Log CSV", data=f, file_name=fname.name, mime="text/csv")
+
+        if HF_TOKEN and HF_REPO_ID and hf_api:
+            with st.spinner("Uploading log to Hugging Face Hub..."):
+                try:
+                    url = hf_api.upload_file(
+                        path_or_fileobj=str(fname),
+                        path_in_repo=f"logs/{fname.name}",
+                        repo_id=HF_REPO_ID,
+                        repo_type="dataset",
+                        token=HF_TOKEN
+                    )
+                    st.success(f"✅ Log successfully uploaded to Hugging Face! [View File]({url})")
+                except Exception as e_upload:
+                    st.error(f"Upload to Hugging Face failed: {e_upload}")
+    except Exception as e_save:
+        st.error(f"Error processing or saving log data: {e_save}")
+
 
 # -----------------------------------------------------------------------------
-# 4. Streamlit UI (Minor adjustments for clarity)
+# 4. Streamlit UI (Adjusted Dashboard Labels)
 # -----------------------------------------------------------------------------
 st.title("🍺 The Beer Game: A Human-AI Collaboration Challenge")
 
@@ -576,8 +553,8 @@ else:
         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**.
         * `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).
-        * `Arriving Next Week`: The quantity scheduled to arrive at the start of the **next 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.
         * `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**.
 
@@ -630,7 +607,7 @@ else:
                         last_week_cost = state['logs'][-1][f"{human_role}.weekly_cost"] if week > 1 and state['logs'] else 0
                         st.metric("Cost Last Week", f"${last_week_cost:,.2f}")
 
-                    # Display info about THIS week's events
+                    # Display info about THIS week's events / NEXT week's arrivals
                     st.write(f"Incoming Order (This Week): **{e['incoming_order']}**") # Order arriving in Step 2
                     if name == "Factory":
                         # Production completing NEXT week
@@ -663,9 +640,9 @@ else:
         # Prepare the state snapshot for the AI prompt (State AFTER arrivals/orders, BEFORE shipping)
         all_decision_point_states = {}
         for name in echelon_order:
-            e_curr = echelons[name]
+            e_curr = echelons[name] # This is END OF LAST WEEK state
             arrived = 0
-            # Peek at what *will* arrive this week (Step 1)
+            # Peek at what *will* arrive this week (Step 1) based on current queues
             if name == "Factory":
                  # Peek at production pipeline
                  if state['factory_production_pipeline']: arrived = list(state['factory_production_pipeline'])[0]
@@ -673,11 +650,16 @@ else:
                  # Peek at incoming shipments
                  if e_curr['incoming_shipments']: arrived = list(e_curr['incoming_shipments'])[0]
 
+            # Calculate the state AFTER arrivals and incoming orders for the prompt
+            inv_after_arrival = e_curr['inventory'] + arrived
+            backlog_after_new_order = e_curr['backlog'] + e_curr['incoming_order']
+
             all_decision_point_states[name] = {
                 'name': name,
-                'inventory': e_curr['inventory'] + arrived, # Opening Inv + Arriving This Week
-                'backlog': e_curr['backlog'] + e_curr['incoming_order'], # Opening Backlog + Incoming Order This Week
-                'incoming_order': e_curr['incoming_order'],
+                'inventory': inv_after_arrival, # State for decision making
+                'backlog': backlog_after_new_order, # State for decision making
+                'incoming_order': e_curr['incoming_order'], # Info for decision making
+                 # Pass queue state as it is at start of week for prompt context
                 'incoming_shipments': e_curr['incoming_shipments'].copy() if name != "Factory" else deque()
             }
         human_echelon_state_for_prompt = all_decision_point_states[human_role]
@@ -740,6 +722,7 @@ else:
                     else:
                         display_df = history_df[final_cols_to_display].rename(columns=human_cols)
                         if 'Weekly Cost' in display_df.columns:
+                            # Safely apply formatting, handling potential non-numeric data
                             display_df['Weekly Cost'] = display_df['Weekly Cost'].apply(lambda x: f"${x:,.2f}" if isinstance(x, (int, float)) else "")
                         st.dataframe(display_df.sort_values(by="Week", ascending=False), hide_index=True, use_container_width=True)
                 except Exception as e: