Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py
-# @title Beer Game Final Version (Manual Setting Selection)
+# @title Beer Game Final Version (Verbatim Restore with Manual Settings)
 
 # -----------------------------------------------------------------------------
 # 1. Import Libraries
@@ -120,9 +120,9 @@ def init_game_state(llm_personality: str, info_sharing: str, participant_id: str
     for i, name in enumerate(roles):
         upstream = roles[i + 1] if i + 1 < len(roles) else None
         downstream = roles[i - 1] if i - 1 >= 0 else None
-        if name == "Distributor": shipping_weeks = FACTORY_SHIPPING_DELAY # This is 1
+        if name == "Distributor": shipping_weeks = FACTORY_SHIPPING_DELAY 
         elif name == "Factory": shipping_weeks = 0
-        else: shipping_weeks = SHIPPING_DELAY # This is 2
+        else: shipping_weeks = SHIPPING_DELAY 
         st.session_state.game_state['echelons'][name] = {
             'name': name, 'inventory': INITIAL_INVENTORY, 'backlog': INITIAL_BACKLOG,
             'incoming_shipments': deque([0] * shipping_weeks, maxlen=shipping_weeks),
@@ -147,23 +147,23 @@ 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 4. Raw Response: '{raw_text}'")
             return 4, raw_text
         except Exception as e:
-            st.error(f"API call failed for {echelon_name}: {e}.")
+            st.error(f"API call failed for {echelon_name}: {e}. Defaulting to 4.")
             return 4, f"API_ERROR: {e}"
 
 def get_llm_prompt(echelon_state_decision_point: dict, week: int, llm_personality: str, info_sharing: str, all_echelons_state_decision_point: dict) -> str:
     e_state = echelon_state_decision_point
     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"
-    
-    current_stable_demand = get_customer_demand(week) 
     if e_state['name'] == 'Factory':
         task_word = "production quantity"
         base_info += f"- Your Production Pipeline (completing next week onwards): {list(st.session_state.game_state['factory_production_pipeline'])}"
     else:
         task_word = "order quantity"
         base_info += f"- Shipments In Transit To You (arriving next week onwards): {list(e_state['incoming_shipments'])}"
-
+    
+    current_stable_demand = get_customer_demand(week)
     if llm_personality == 'perfect_rational' and info_sharing == 'full':
         stable_demand = current_stable_demand
         if e_state['name'] == 'Factory': total_lead_time = FACTORY_LEAD_TIME
@@ -171,84 +171,70 @@ def get_llm_prompt(echelon_state_decision_point: dict, week: int, llm_personalit
         else: total_lead_time = ORDER_PASSING_DELAY + SHIPPING_DELAY
         safety_stock = 4
         target_inventory_level = (stable_demand * total_lead_time) + safety_stock
-        order_in_transit_to_supplier = st.session_state.game_state['last_week_orders'].get(e_state['name'], 0)
-        
         if e_state['name'] == 'Factory':
-            supply_line = sum(st.session_state.game_state['factory_production_pipeline'])
-            inventory_position = (e_state['inventory'] - e_state['backlog'] + supply_line)
-            inv_pos_components = f"(Inv={e_state['inventory']} - Backlog={e_state['backlog']} + InProd={supply_line})"
-        elif e_state['name'] == 'Distributor':
-            in_shipping = sum(e_state['incoming_shipments'])
-            in_production = sum(st.session_state.game_state['factory_production_pipeline'])
-            supply_line = in_shipping + in_production + order_in_transit_to_supplier
-            inventory_position = (e_state['inventory'] - e_state['backlog'] + supply_line)
-            inv_pos_components = f"(Inv={e_state['inventory']} - Backlog={e_state['backlog']} + InTransitShip={in_shipping} + InProd={in_production} + OrderToSupplier={order_in_transit_to_supplier})"
+            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:
-            in_shipping = sum(e_state['incoming_shipments'])
-            supply_line = in_shipping + order_in_transit_to_supplier
-            inventory_position = (e_state['inventory'] - e_state['backlog'] + supply_line)
-            inv_pos_components = f"(Inv={e_state['inventory']} - Backlog={e_state['backlog']} + InTransitShip={in_shipping} + OrderToSupplier={order_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))
         return f"**You are a perfectly rational supply chain AI with full system visibility.**\nYour only goal is to maintain stability and minimize costs based on mathematical optimization.\n**System Analysis:**\n* **Known Stable End-Customer Demand:** {stable_demand} units/week.\n* **Your Current Total Inventory Position:** {inventory_position} units. {inv_pos_components}\n* **Optimal Target Inventory Level:** {target_inventory_level} units (Target for {total_lead_time} weeks lead time).\n* **Mathematically Optimal {task_word.title()}:** The optimal decision is **{optimal_order} units**.\n**Your Task:** Confirm this optimal {task_word}. Respond with a single integer."
-    
     elif llm_personality == 'perfect_rational' and info_sharing == 'local':
         safety_stock = 4; anchor_demand = e_state['incoming_order']
         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"
-        elif e_state['name'] == 'Distributor':
-            supply_line = sum(e_state['incoming_shipments'])
-            supply_line_desc = "Supply Line (In Transit Shipments)"
         else:
-            supply_line = sum(e_state['incoming_shipments'])
-            supply_line_desc = "Supply Line (In Transit Shipments)"
-        
+            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 (that you can see). These should be subtracted from your new decision.\n\n**Final Calculation:**\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."
-    
-    else: 
-        DESIRED_INVENTORY = 12
-        net_inventory = e_state['inventory'] - e_state['backlog']
-        stock_correction = DESIRED_INVENTORY - net_inventory
-        if e_state['name'] == 'Factory':
-            supply_line = sum(st.session_state.game_state['factory_production_pipeline'])
-            supply_line_desc = "In Production"
-        else:
-            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"
-            
-        if info_sharing == 'local':
-            anchor_demand = e_state['incoming_order']
-            panicky_order = max(0, int(anchor_demand + stock_correction))
-            return f"""**You are a reactive supply chain manager for the {e_state['name']}.** You have a limited (local) view.\n{base_info}\n**Your 'Panic' Calculation:**\n1. Anchor on Demand ({anchor_demand} units).\n2. Correct for Stock (Need {stock_correction} more units).\n3. Ignore Supply Line ({supply_line} units).\n**Final Panic Order:** **{panicky_order} units**. Respond with a single integer."""
-        elif info_sharing == 'full':
-            local_anchor = e_state['incoming_order']
-            global_anchor = current_stable_demand
-            anchor_demand = int((local_anchor + global_anchor) / 2) 
-            panicky_order = max(0, int(anchor_demand + stock_correction))
-            full_info_str = f"\n**Full Supply Chain Information:**\n- End-Customer Demand this week: {current_stable_demand} units.\n"
-            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"""**You are a supply chain manager ({e_state['name']}) with full system visibility.**\n{base_info}\n{full_info_str}\n**Your 'Panic' Calculation:**\n1. Anchor on Conflict (Average of local {local_anchor} and global {global_anchor} = {anchor_demand}).\n2. Correct for Stock (Need {stock_correction} more units).\n3. Ignore Supply Line.\n**Final Panic Order:** **{panicky_order} units**. 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_correction} - {supply_line} = **{rational_local_order} units**.\n**Your Task:** Confirm this locally rational {task_word}. Respond with a single integer."
+    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_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"""
+        **You are a supply chain manager ({e_state['name']}) with full system visibility.**
+        You can see everyone's current inventory and backlog before shipping, and the real customer demand.
+        {base_info}
+        {full_info_str}
+        **Your Task:** Your primary responsibility is to meet the demand from your direct customer (your `Incoming order this week`: **{e_state['incoming_order']}** units), which contributes to your total current backlog of {e_state['backlog']}.
+        While you can see the stable end-customer demand ({get_customer_demand(week)} units), your priority is to fulfill the order you just received and manage your inventory/backlog.
+        You are still human and might get anxious about your own stock levels.
+        What {task_word} should you decide on this week? Respond with a single integer.
+        """
+    elif llm_personality == 'human_like' and info_sharing == 'local':
+        return f"""
+        **You are a reactive supply chain manager for the {e_state['name']}.** You have a limited view and tend to over-correct based on fear.
+        Your top priority is to NOT have a backlog.
+        {base_info}
+        **Your Task:** You just received an incoming order for **{e_state['incoming_order']}** units, adding to your total backlog.
+        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.
+        """
 
 def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: int):
+    # This is the correct logic from v4.17
     state = st.session_state.game_state
     week, echelons, human_role = state['week'], state['echelons'], state['human_role']
     llm_personality, info_sharing = state['llm_personality'], state['info_sharing']
     echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     llm_raw_responses = {}
+    
+    # Capture opening state for logging
     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}
     opening_arriving_next_week_UI_VALUE = {name: 0 for name in echelon_order} 
 
+    # Logic from v4.17
     factory_q = state['factory_production_pipeline']
-    if factory_q: arrived_this_week["Factory"] = factory_q[0]
+    if factory_q:
+        arrived_this_week["Factory"] = factory_q[0] 
     opening_arriving_next_week_UI_VALUE["Factory"] = state['last_week_orders'].get("Distributor", 0)
 
     for name in ["Retailer", "Wholesaler", "Distributor"]:
@@ -261,62 +247,74 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
                 opening_arriving_next_week_UI_VALUE[name] = shipment_q[0]
 
     inventory_after_arrival = {}
-    produced_units = state['factory_production_pipeline'].popleft() if state['factory_production_pipeline'] else 0
-    inventory_after_arrival["Factory"] = echelons["Factory"]['inventory'] + produced_units
-
+    factory_state = echelons["Factory"]
+    produced_units = 0
+    if state['factory_production_pipeline']:
+        produced_units = state['factory_production_pipeline'].popleft()
+    inventory_after_arrival["Factory"] = factory_state['inventory'] + produced_units
+    
     for name in ["Retailer", "Wholesaler", "Distributor"]:
         arrived_shipment = arrived_this_week[name]
-        if echelons[name]['incoming_shipments']: echelons[name]['incoming_shipments'].popleft()
+        if echelons[name]['incoming_shipments']:
+            echelons[name]['incoming_shipments'].popleft() 
         inventory_after_arrival[name] = echelons[name]['inventory'] + arrived_shipment
 
     total_backlog_before_shipping = {}
     for name in echelon_order:
-        incoming_order_for_this_week = get_customer_demand(week) if name == "Retailer" else state['last_week_orders'].get(echelons[name]['downstream_name'], 0)
+        incoming_order_for_this_week = 0
+        if name == "Retailer": incoming_order_for_this_week = get_customer_demand(week)
+        else:
+            downstream_name = echelons[name]['downstream_name']
+            if downstream_name: incoming_order_for_this_week = state['last_week_orders'].get(downstream_name, 0)
         echelons[name]['incoming_order'] = incoming_order_for_this_week
         total_backlog_before_shipping[name] = echelons[name]['backlog'] + incoming_order_for_this_week
-
+    
     decision_point_states = {}
     for name in echelon_order:
-        decision_point_states[name] = {
-            'name': name, 'inventory': inventory_after_arrival[name],
-            'backlog': total_backlog_before_shipping[name], 'incoming_order': echelons[name]['incoming_order'],
-            'incoming_shipments': echelons[name]['incoming_shipments'].copy() if name != "Factory" else deque(),
-        }
+         decision_point_states[name] = {
+             'name': name, 'inventory': inventory_after_arrival[name],
+             'backlog': total_backlog_before_shipping[name], 'incoming_order': echelons[name]['incoming_order'],
+             'incoming_shipments': echelons[name]['incoming_shipments'].copy() if name != "Factory" else deque(),
+         }
 
     current_week_orders = {}
     for name in echelon_order:
+        e = echelons[name]; prompt_state = decision_point_states[name]
         if name == human_role: order_amount, raw_resp = human_final_order, "HUMAN_FINAL_INPUT"
         else:
-            prompt = get_llm_prompt(decision_point_states[name], week, llm_personality, info_sharing, decision_point_states)
+            prompt = get_llm_prompt(prompt_state, week, llm_personality, info_sharing, decision_point_states)
             order_amount, raw_resp = get_llm_order_decision(prompt, name)
-        llm_raw_responses[name] = raw_resp; echelons[name]['order_placed'] = max(0, order_amount); current_week_orders[name] = echelons[name]['order_placed']
-
+        llm_raw_responses[name] = raw_resp; e['order_placed'] = max(0, order_amount); current_week_orders[name] = e['order_placed']
+    
     state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
     units_shipped = {name: 0 for name in echelon_order}
     for name in echelon_order:
-        demand = total_backlog_before_shipping[name]; avail = inventory_after_arrival[name]
-        echelons[name]['shipment_sent'] = min(avail, demand); units_shipped[name] = echelons[name]['shipment_sent']
-        echelons[name]['inventory'] = avail - units_shipped[name]; echelons[name]['backlog'] = demand - units_shipped[name]
-
+        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']
+        e['inventory'] = available_inv - e['shipment_sent']; e['backlog'] = demand_to_meet - e['shipment_sent']
+    
     if units_shipped["Factory"] > 0: echelons['Distributor']['incoming_shipments'].append(units_shipped["Factory"])
     if units_shipped['Distributor'] > 0: echelons['Wholesaler']['incoming_shipments'].append(units_shipped['Distributor'])
     if units_shipped['Wholesaler'] > 0: echelons['Retailer']['incoming_shipments'].append(units_shipped['Wholesaler'])
-
+    
     log_entry = {'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week, **state}
     del log_entry['echelons'], log_entry['factory_production_pipeline'], log_entry['logs'], log_entry['last_week_orders']
+    if 'current_ai_suggestion' in log_entry: del log_entry['current_ai_suggestion']
+    
     for name in echelon_order:
         e = echelons[name]; e['weekly_cost'] = (e['inventory'] * HOLDING_COST) + (e['backlog'] * BACKLOG_COST); e['total_cost'] += e['weekly_cost']
         for key in ['inventory', 'backlog', 'incoming_order', 'order_placed', 'shipment_sent', 'weekly_cost', 'total_cost']: log_entry[f'{name}.{key}'] = e[key]
+        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]
         if name != 'Factory': log_entry[f'{name}.arriving_next_week'] = opening_arriving_next_week_UI_VALUE[name]
         else: log_entry[f'{name}.production_completing_next_week'] = opening_arriving_next_week_UI_VALUE[name]
-
+    
     log_entry[f'{human_role}.initial_order'] = human_initial_order; log_entry[f'{human_role}.ai_suggestion'] = ai_suggestion
     state['logs'].append(log_entry)
     state['week'] += 1; state['decision_step'] = 'initial_order'; state['last_week_orders'] = current_week_orders
-    state['current_ai_suggestion'] = None
+    state['current_ai_suggestion'] = None # Clean up
     if state['week'] > WEEKS: state['game_running'] = False
 
 def plot_results(df: pd.DataFrame, title: str, human_role: str):
@@ -333,15 +331,19 @@ def plot_results(df: pd.DataFrame, title: str, human_role: str):
     inventory_pivot = plot_df.pivot(index='week', columns='echelon', values='inventory').reindex(columns=echelons)
     inventory_pivot.plot(ax=axes[0], kind='line', marker='o', markersize=4); axes[0].set_title('Inventory Levels (End of Week)'); axes[0].grid(True, linestyle='--'); axes[0].set_ylabel('Stock (Units)')
     order_pivot = plot_df.pivot(index='week', columns='echelon', values='order_placed').reindex(columns=echelons)
-    order_pivot.plot(ax=axes[1], style='--'); axes[1].plot(range(1, WEEKS + 1), [get_customer_demand(w) for w in range(1, WEEKS + 1)], label='Customer Demand', color='black', lw=2.5); axes[1].set_title('Order Quantities / Production Decisions'); axes[1].grid(True, linestyle='--'); axes[1].legend(); axes[1].set_ylabel('Ordered/Produced (Units)')
-    total_costs = plot_df.loc[plot_df.groupby('echelon')['week'].idxmax()].set_index('echelon')['total_cost'].reindex(echelons, fill_value=0)
+    order_pivot.plot(ax=axes[1], style='--'); axes[1].plot(range(1, WEEKS + 1), [get_customer_demand(week) for week in range(1, WEEKS + 1)], label='Customer Demand', color='black', lw=2.5); axes[1].set_title('Order Quantities / Production Decisions'); axes[1].grid(True, linestyle='--'); axes[1].legend(); axes[1].set_ylabel('Ordered/Produced (Units)')
+    total_costs = plot_df.loc[plot_df.groupby('echelon')['week'].idxmax()]
+    total_costs = total_costs.set_index('echelon')['total_cost'].reindex(echelons, fill_value=0)
     total_costs.plot(kind='bar', ax=axes[2], rot=0); axes[2].set_title('Total Cumulative Cost'); axes[2].set_ylabel('Cost ($)')
     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]
     try:
-        human_df = df[human_df_cols].copy().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'})
-        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')
-    except: axes[3].text(0.5, 0.5, "No human decision data", ha='center', va='center')
+        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: 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
 
 @st.cache_data(ttl=60)
@@ -350,20 +352,27 @@ def load_leaderboard_data():
     try:
         local_path = hf_hub_download(repo_id=HF_REPO_ID, repo_type="dataset", filename=LEADERBOARD_FILE, token=HF_TOKEN, cache_dir=LOCAL_LOG_DIR / "hf_cache")
         with open(local_path, 'r', encoding='utf-8') as f: return json.load(f)
-    except: return {}
+    except EntryNotFoundError:
+        return {}
+    except Exception as e:
+        st.sidebar.error(f"Could not load leaderboard: {e}")
+        return {}
 
 def save_leaderboard_data(data):
     if not hf_api or not HF_REPO_ID or not HF_TOKEN: return
     try:
         local_path = LOCAL_LOG_DIR / LEADERBOARD_FILE
         with open(local_path, 'w', encoding='utf-8') as f: json.dump(data, f, indent=2, ensure_ascii=False)
-        hf_api.upload_file(path_or_fileobj=str(local_path), path_in_repo=LEADERBOARD_FILE, repo_id=HF_REPO_ID, repo_type="dataset", token=HF_TOKEN)
+        hf_api.upload_file(path_or_fileobj=str(local_path), path_in_repo=LEADERBOARD_FILE, repo_id=HF_REPO_ID, repo_type="dataset", token=HF_TOKEN, commit_message="Update leaderboard")
         st.cache_data.clear()
-    except: pass
+    except Exception as e:
+        st.sidebar.error(f"Failed to upload leaderboard: {e}")
 
 def display_rankings(df, top_n=200):
-    if df.empty: return
-    df['distributor_cost'] = pd.to_numeric(df.get('total_cost'), errors='coerce')
+    if df.empty:
+        st.info("No completed games for this category yet. Be the first!")
+        return
+    df['distributor_cost'] = pd.to_numeric(df.get('total_cost'), errors='coerce') 
     df['total_chain_cost'] = pd.to_numeric(df.get('total_chain_cost'), errors='coerce')
     df['order_std_dev'] = pd.to_numeric(df.get('order_std_dev'), errors='coerce')
     c1, c2, c3 = st.columns(3)
@@ -372,56 +381,97 @@ def display_rankings(df, top_n=200):
         champs_df = df.dropna(subset=['total_chain_cost']).sort_values('total_chain_cost', ascending=True).head(top_n).copy()
         if not champs_df.empty:
             champs_df['total_chain_cost'] = champs_df['total_chain_cost'].map('${:,.2f}'.format)
-            st.dataframe(champs_df[['id', 'total_chain_cost']], use_container_width=True, hide_index=True)
+            champs_df.rename(columns={'id': 'Participant', 'total_chain_cost': 'Total Chain Cost'}, inplace=True)
+            st.dataframe(champs_df[['Participant', 'Total Chain Cost']], use_container_width=True, hide_index=True)
     with c2:
         st.subheader("👤 Distributor Champions")
         dist_df = df.dropna(subset=['distributor_cost']).sort_values('distributor_cost', ascending=True).head(top_n).copy()
         if not dist_df.empty:
             dist_df['distributor_cost'] = dist_df['distributor_cost'].map('${:,.2f}'.format)
-            st.dataframe(dist_df[['id', 'distributor_cost']], use_container_width=True, hide_index=True)
+            dist_df.rename(columns={'id': 'Participant', 'distributor_cost': 'Your Cost'}, inplace=True)
+            st.dataframe(dist_df[['Participant', 'Your Cost']], use_container_width=True, hide_index=True)
     with c3:
         st.subheader("🧘 Mr. Smooth")
         smooth_df = df.dropna(subset=['order_std_dev']).sort_values('order_std_dev', ascending=True).head(top_n).copy()
         if not smooth_df.empty:
             smooth_df['order_std_dev'] = smooth_df['order_std_dev'].map('{:,.2f}'.format)
-            st.dataframe(smooth_df[['id', 'order_std_dev']], use_container_width=True, hide_index=True)
+            smooth_df.rename(columns={'id': 'Participant', 'order_std_dev': 'Order Std. Dev.'}, inplace=True)
+            st.dataframe(smooth_df[['Participant', 'Order Std. Dev.']], use_container_width=True, hide_index=True)
 
 def show_leaderboard_ui():
     st.markdown("---")
     st.header("📊 The Bullwhip Leaderboard")
     leaderboard_data = load_leaderboard_data()
-    if leaderboard_data:
-        df = pd.DataFrame(leaderboard_data.values())
-        if 'id' not in df.columns: df['id'] = list(leaderboard_data.keys())
-        groups = sorted(df.setting.unique())
-        tabs = st.tabs(["**Overall**"] + groups)
-        with tabs[0]: display_rankings(df)
-        for i, group_name in enumerate(groups):
-            with tabs[i+1]: display_rankings(df[df.setting == group_name].copy())
+    if not leaderboard_data:
+        st.info("No leaderboard data yet. Be the first to finish a game!")
+    else:
+        try:
+            df = pd.DataFrame(leaderboard_data.values())
+            if 'id' not in df.columns and not df.empty: df['id'] = list(leaderboard_data.keys())
+            if 'total_cost' not in df.columns or 'order_std_dev' not in df.columns or 'setting' not in df.columns:
+                st.error("Leaderboard data is corrupted or incomplete.")
+                return
+            groups = sorted(df.setting.unique())
+            tabs = st.tabs(["**Overall**"] + groups)
+            with tabs[0]: display_rankings(df)
+            for i, group_name in enumerate(groups):
+                with tabs[i+1]:
+                    df_group = df[df.setting == group_name].copy()
+                    display_rankings(df_group)
+        except Exception as e:
+            st.error(f"Error displaying leaderboard: {e}")
 
 def save_logs_and_upload(state: dict):
-    if not state.get('logs'): return
+    if not state.get('logs'):
+        st.warning("No log data to save.")
+        return
     participant_id = state['participant_id']
+    logs_df = None
     try:
         logs_df = pd.json_normalize(state['logs'])
-        fname = LOCAL_LOG_DIR / f"log_{participant_id}_{int(time.time())}.csv"
+        safe_participant_id = re.sub(r'[^a-zA-Z0-9_-]', '_', participant_id)
+        fname = LOCAL_LOG_DIR / f"log_{safe_participant_id}_{int(time.time())}.csv"
         logs_df['experiment_end_timestamp'] = datetime.utcnow().isoformat() + "Z"
-        logs_df['consent_given_timestamp'] = st.session_state.get('consent_timestamp', "N/A")
+        if st.session_state.get('consent_timestamp'):
+            logs_df['consent_given_timestamp'] = st.session_state['consent_timestamp']
+        else: 
+            logs_df['consent_given_timestamp'] = "N/A"
+        for col in logs_df.select_dtypes(include=['object']).columns: logs_df[col] = logs_df[col].astype(str)
         logs_df.to_csv(fname, index=False)
-        st.download_button("📥 Download Log CSV", data=open(fname, "rb"), file_name=fname.name, mime="text/csv")
+        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:
-            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)
-    except: return
+            with st.spinner("Uploading log CSV 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 CSV successfully uploaded! [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 CSV: {e_save}")
+        return
+    if logs_df is None: return
     try:
         human_role = state['human_role']
-        dist_cost = logs_df[f'{human_role}.total_cost'].iloc[-1]
-        total_chain_cost = sum(logs_df[f'{e}.total_cost'].iloc[-1] for e in ["Retailer", "Wholesaler", "Distributor", "Factory"])
+        distributor_cost = logs_df[f'{human_role}.total_cost'].iloc[-1]
+        r_cost = logs_df['Retailer.total_cost'].iloc[-1]
+        w_cost = logs_df['Wholesaler.total_cost'].iloc[-1]
+        f_cost = logs_df['Factory.total_cost'].iloc[-1]
+        total_chain_cost = r_cost + w_cost + distributor_cost + f_cost
         order_std_dev = logs_df[f'{human_role}.order_placed'].std()
-        new_entry = {'id': participant_id, 'setting': f"{state['llm_personality']} / {state['info_sharing']}", 'total_cost': float(dist_cost), 'total_chain_cost': float(total_chain_cost), 'order_std_dev': float(order_std_dev) if pd.notna(order_std_dev) else 0.0, 'start_timestamp': state.get('start_timestamp'), 'consent_timestamp': st.session_state.get('consent_timestamp')}
+        setting_name = f"{state['llm_personality']} / {state['info_sharing']}"
+        new_entry = {
+            'id': participant_id, 'setting': setting_name,
+            'total_cost': float(distributor_cost),
+            'total_chain_cost': float(total_chain_cost),
+            'order_std_dev': float(order_std_dev) if pd.notna(order_std_dev) else 0.0,
+            'start_timestamp': state.get('start_timestamp'),
+            'consent_timestamp': st.session_state.get('consent_timestamp')
+        }
         leaderboard_data = load_leaderboard_data()
-        leaderboard_data[participant_id] = new_entry
+        leaderboard_data[participant_id] = new_entry 
         save_leaderboard_data(leaderboard_data)
-    except: pass
+    except Exception as e_board:
+        st.error(f"Error calculating or saving leaderboard score: {e_board}")
 
 # -----------------------------------------------------------------------------
 # 4. Streamlit UI
@@ -435,14 +485,13 @@ if 'comprehension_passed' not in st.session_state: st.session_state['comprehensi
 
 if st.session_state.get('initialization_error'):
     st.error(st.session_state.initialization_error)
-
 elif not st.session_state['consent_given']:
     st.header("📝 Participant Consent Form")
-    st.markdown("... (Consent Text) ...")
+    st.markdown("""**Lead Researcher:** Xinyu Li...""") # (Long text same as before)
     with st.form("consent_form"):
-        choice = st.radio("**Do you agree to take part?**", ('Yes', 'No'), index=None)
+        consent_choice = st.radio("**Do you agree?**", ('Yes', 'No'), index=None)
         if st.form_submit_button("Continue"):
-            if choice == 'Yes':
+            if consent_choice == 'Yes':
                 st.session_state['consent_given'] = True
                 st.session_state['consent_timestamp'] = datetime.utcnow().isoformat() + "Z"
                 st.rerun()
@@ -450,29 +499,41 @@ elif not st.session_state['consent_given']:
 
 elif not st.session_state['comprehension_passed']:
     st.header("🧠 Comprehension Check")
-    with st.form("quiz"):
-        correct = True
-        for i, q in enumerate(COMPRE_QUESTIONS := COMPREHENSION_QUESTIONS):
-            ans = st.radio(q['q'], q['options'], index=None)
-            if ans != q['options'][q['correct_index']]: correct = False
-        if st.form_submit_button("Submit"):
-            if correct: st.session_state['comprehension_passed'] = True; st.rerun()
+    with st.form("comprehension_quiz"):
+        user_answers = {}
+        for i, q_data in enumerate(COMPREHENSION_QUESTIONS):
+            st.subheader(q_data['q'])
+            user_answers[i] = st.radio("Select:", q_data['options'], key=f"comp_q_{i}", index=None)
+        if st.form_submit_button("Submit Answers"):
+            all_correct = True
+            for i, q_data in enumerate(COMPREHENSION_QUESTIONS):
+                if user_answers.get(i) != q_data['options'][q_data['correct_index']]:
+                    all_correct = False
+            if all_correct: st.session_state['comprehension_passed'] = True; st.rerun()
             else: st.error("Incorrect answers.")
 
 else:
-    is_game_over = st.session_state.get('game_state') and not st.session_state.game_state.get('game_running') and st.session_state.game_state.get('week', 0) > WEEKS
+    is_game_state_present = st.session_state.get('game_state') is not None
+    is_game_running = st.session_state.get('game_state', {}).get('game_running', False)
+    is_game_over = is_game_state_present and not is_game_running and st.session_state.get('game_state', {}).get('week', 0) > WEEKS
+
     if is_game_over:
         st.header("🎉 Game Over!")
         state = st.session_state.game_state
-        url = f"{QUALTRICS_BASE_URL}?{PID_FIELD_NAME}={state['participant_id']}"
-        st.info(f"ID: **{state['participant_id']}**. [Complete Survey]({url})")
-        save_logs_and_upload(state)
-        if st.button("✨ Start New Game"):
+        participant_id = state['participant_id']
+        url = f"{QUALTRICS_BASE_URL}?{PID_FIELD_NAME}={participant_id}"
+        st.markdown(f'<a href="{url}" target="_blank"><button style="...">Click Start Survey</button></a>', unsafe_allow_html=True)
+        try:
+            logs_df = pd.json_normalize(state['logs'])
+            st.pyplot(plot_results(logs_df, f"Beer Game (Human: {state['human_role']})", state['human_role']))
+            save_logs_and_upload(state)
+        except Exception as e: st.error(f"Error: {e}")
+        if st.button("✨ Start a New Game"):
             for k in ['consent_timestamp', 'consent_given', 'comprehension_passed', 'game_state']: 
                 if k in st.session_state: del st.session_state[k]
             st.rerun()
 
-    elif st.session_state.get('game_state', {}).get('game_running'):
+    elif is_game_running:
         state = st.session_state.game_state
         week, human_role, echelons, info_sharing = state['week'], state['human_role'], state['echelons'], state['info_sharing']
         echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"]
@@ -483,8 +544,9 @@ else:
             for i, name in enumerate(echelon_order):
                 with cols[i]:
                     e = echelons[name]
-                    label = f"##### **<span style='border: 1px solid #FF4B4B; padding: 2px 5px;'>{'👤' if name==human_role else '🤖'} {name} {'(You)' if name==human_role else ''}</span>**" if name==human_role else f"##### {'🤖'} {name}"
-                    st.markdown(label, unsafe_allow_html=True)
+                    if name == human_role:
+                        st.markdown(f"##### **<span style='border: 1px solid #FF4B4B; padding: 2px 5px;'>👤 {name} (You)</span>**", unsafe_allow_html=True)
+                    else: st.markdown(f"##### 🤖 {name}")
                     st.metric("Inventory", e['inventory']); st.metric("Backlog", e['backlog'])
                     st.write(f"Incoming Order: **{e['incoming_order']}**")
                     if name == "Factory": st.write(f"Completing Next: **{state['last_week_orders'].get('Distributor', 0)}**")
@@ -493,54 +555,52 @@ else:
             e = echelons[human_role]
             st.markdown(f"### <span style='color:#FF4B4B;'>👤 {human_role} (Your Dashboard)</span>", unsafe_allow_html=True)
             c1, c2, c3 = st.columns(3)
-            c1.metric("Inventory", e['inventory']); c1.metric("Backlog", e['backlog'])
-            c2.write(f"**Incoming Order:**\n# {e['incoming_order']}")
-            c3.write(f"**Arriving Next:**\n# {list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}")
+            with c1: st.metric("Inventory", e['inventory']); st.metric("Backlog", e['backlog'])
+            with c2: st.write(f"**Incoming Order:**\n# {e['incoming_order']}")
+            with c3: st.write(f"**Arriving Next:**\n# {list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}")
 
         st.markdown("---")
-        # Decision Step logic re-integrated correctly
+        st.header("Your Decision")
         if state['decision_step'] == 'initial_order':
-            with st.form("init_form"):
-                val = st.number_input("Initial Order:", min_value=0, step=1, value=None)
-                if st.form_submit_button("Next"):
-                    state['human_initial_order'] = int(val) if val is not None else 0
+            with st.form(key="initial_order_form"):
+                initial_order = st.number_input("Your Initial Order Quantity:", min_value=0, step=1, value=None)
+                if st.form_submit_button("Submit Initial Order & See AI Suggestion", type="primary"):
+                    state['human_initial_order'] = int(initial_order) if initial_order is not None else 0
                     state['decision_step'] = 'final_order'
-                     snap = {n: {'name': n, 'inventory': echelons[n]['inventory'], 'backlog': echelons[n]['backlog'], 'incoming_order': echelons[n]['incoming_order']} for n in echelon_order}
-                    state['current_ai_suggestion'], _ = get_llm_order_decision(get_llm_prompt(snap[human_role], week, state['llm_personality'], info_sharing, snap), human_role)
+                    snap = {n: {'name': n, 'inventory': echelons[n]['inventory'], 'backlog': echelons[n]['backlog'], 'incoming_order': echelons[n]['incoming_order']} for n in echelon_order}
+                    prompt_sugg = get_llm_prompt(snap[human_role], week, state['llm_personality'], info_sharing, snap)
+                    ai_suggestion, _ = get_llm_order_decision(prompt_sugg, human_role)
+                    state['current_ai_suggestion'] = ai_suggestion
                     st.rerun()
         else:
-            with st.form("final_form"):
-                st.write(f"AI Suggests: **{state['current_ai_suggestion']}**")
-                val = st.number_input("Final Order:", min_value=0, step=1, key="final_order_input", value=None)
-                if st.form_submit_button("Submit"):
-                    step_game(int(val) if val is not None else 0, state['human_initial_order'], state['current_ai_suggestion'])
+            ai_suggestion = state.get('current_ai_suggestion', 4)
+            with st.form(key="final_order_form"):
+                st.write(f"#### AI Suggestion: **{ai_suggestion}** units")
+                final_order = st.number_input("Your Final Order Quantity:", min_value=0, step=1, key='final_order_input', value=None)
+                if st.form_submit_button("Submit Final Order & Advance"):
+                    step_game(int(final_order) if final_order is not None else 0, state['human_initial_order'], ai_suggestion)
                     st.rerun()
 
-        st.sidebar.image(IMAGE_PATH, use_column_width=True) if Path(IMAGE_PATH).exists() else None
-        if st.sidebar.button("🔄 Reset"): 
-            if 'game_state' in st.session_state: del st.session_state.game_state
-            st.rerun()
-
     else:
         st.header("⚙️ Game Configuration")
-        pid = st.text_input("Name/Team ID:", key="pid_input")
+        participant_id = st.text_input("Enter Your Name or Team ID:", key="participant_id_input")
         
-        # --- MODIFIED: Manual Setting Selection ---
+        # --- 恢复手动选择配置 ---
         c1, c2 = st.columns(2)
         with c1:
-            llm_p = st.selectbox("AI Personality", ('human_like', 'perfect_rational'), format_func=lambda x: x.replace('_', ' ').title())
+            llm_personality = st.selectbox("AI Agent Personality", ('human_like', 'perfect_rational'), format_func=lambda x: x.replace('_', ' ').title())
         with c2:
-            info_s = st.selectbox("Information Sharing", ('local', 'full'), format_func=lambda x: x.title())
+            info_sharing = st.selectbox("Information Sharing Level", ('local', 'full'), format_func=lambda x: x.title())
         
         if st.button("🚀 Start Game", type="primary"):
-            if pid:
-                init_game_state(llm_p, info_s, pid)
+            if participant_id:
+                init_game_state(llm_personality, info_sharing, participant_id)
                 st.rerun()
-            else: st.error("Enter ID.")
+            else: st.error("Please enter an ID.")
         show_leaderboard_ui()
 
 # --- Instructor Zone ---
 st.sidebar.markdown("---")
 with st.sidebar.expander("🔐 Instructor Zone"):
     if st.text_input("Admin Password:", type="password") == ADMIN_PASSWORD:
-        if st.checkbox("Show Leaderboard"): show_leaderboard_ui()
+        if st.checkbox("Show Global Leaderboard"): show_leaderboard_ui()