Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py
-# @title Beer Game Final Version (v4.10 - Added Arrival Log Column - Complete Code)
+# @title Beer Game Final Version (v4.11 - Corrected Order Passing Logic)
 
 # -----------------------------------------------------------------------------
 # 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 # *** CRITICAL: This is now handled directly in step_game ***
 SHIPPING_DELAY = 2 # General shipping delay
 FACTORY_LEAD_TIME = 1
 FACTORY_SHIPPING_DELAY = 1 # Specific delay from Factory to Distributor
@@ -75,20 +75,20 @@ def init_game_state(llm_personality: str, info_sharing: str):
         'factory_production_pipeline': deque([0] * FACTORY_LEAD_TIME, maxlen=FACTORY_LEAD_TIME),
         'decision_step': 'initial_order',
         'human_initial_order': None,
+        'last_week_orders': {name: 0 for name in roles} # Store previous week's final orders
     }
 
     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
 
-        # Determine shipping delay for incoming goods for this role
         if name == "Distributor": shipping_weeks = FACTORY_SHIPPING_DELAY
-        elif name == "Factory": shipping_weeks = 0 # Factory produces, doesn't receive shipments
-        else: shipping_weeks = SHIPPING_DELAY # Retailer/Wholesaler use general delay
+        elif name == "Factory": shipping_weeks = 0
+        else: shipping_weeks = SHIPPING_DELAY
 
         st.session_state.game_state['echelons'][name] = {
             'name': name, 'inventory': INITIAL_INVENTORY, 'backlog': INITIAL_BACKLOG,
-            'order_pipeline': deque([0] * ORDER_PASSING_DELAY, maxlen=ORDER_PASSING_DELAY),
+            # 'order_pipeline' is no longer needed for passing delay = 1
             'incoming_shipments': deque([0] * shipping_weeks, maxlen=shipping_weeks),
             'incoming_order': 0, 'order_placed': 0, 'shipment_sent': 0,
             'weekly_cost': 0, 'total_cost': 0, 'upstream_name': upstream, 'downstream_name': downstream,
@@ -96,6 +96,7 @@ def init_game_state(llm_personality: str, info_sharing: str):
     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.
     if not client: return 8, "NO_API_KEY_DEFAULT"
     with st.spinner(f"Getting AI decision for {echelon_name}..."):
         try:
@@ -125,7 +126,10 @@ def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sh
         base_info += f"- Production pipeline (completing in future weeks): {list(st.session_state.game_state['factory_production_pipeline'])}"
     else:
         task_word = "order quantity"
-        base_info += f"- Shipments on the way to you: {list(echelon_state['incoming_shipments'])}\n- Orders you have placed being processed by your supplier: {list(echelon_state['order_pipeline'])}"
+        # Base info now correctly reflects only incoming shipments for non-factory roles
+        base_info += f"- Shipments on the way to you: {list(echelon_state['incoming_shipments'])}"
+        # We don't need 'Orders in pipeline' in the prompt anymore as delay=1 is handled directly
+
     if llm_personality == 'perfect_rational' and info_sharing == 'full':
         stable_demand = 8
         if echelon_state['name'] == 'Factory': total_lead_time = FACTORY_LEAD_TIME
@@ -137,10 +141,12 @@ def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sh
             inv_pos_components = f"(Inv: {echelon_state['inventory']} - Backlog: {echelon_state['backlog']} + In_Production: {sum(st.session_state.game_state['factory_production_pipeline'])})"
             inventory_position = (echelon_state['inventory'] - echelon_state['backlog'] + sum(st.session_state.game_state['factory_production_pipeline']))
         else:
-            inv_pos_components = f"(Inv: {echelon_state['inventory']} - Backlog: {echelon_state['backlog']} + In_Transit: {sum(echelon_state['incoming_shipments'])} + In_Pipeline: {sum(echelon_state['order_pipeline'])})"
-            inventory_position = (echelon_state['inventory'] - echelon_state['backlog'] + sum(echelon_state['incoming_shipments']) + sum(echelon_state['order_pipeline']))
+            # Simplified inventory position for delay=1
+            inv_pos_components = f"(Inv: {echelon_state['inventory']} - Backlog: {echelon_state['backlog']} + In_Transit: {sum(echelon_state['incoming_shipments'])})"
+            inventory_position = (echelon_state['inventory'] - echelon_state['backlog'] + sum(echelon_state['incoming_shipments']))
         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 = echelon_state['incoming_order']
         inventory_correction = safety_stock - (echelon_state['inventory'] - echelon_state['backlog'])
@@ -148,11 +154,13 @@ def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sh
             supply_line = sum(st.session_state.game_state['factory_production_pipeline'])
             supply_line_desc = "In Production"
         else:
-            supply_line = sum(echelon_state['incoming_shipments']) + sum(echelon_state['order_pipeline'])
-            supply_line_desc = "Supply Line (In Transit + In Pipeline)"
+            # Simplified supply line for delay=1
+            supply_line = sum(echelon_state['incoming_shipments'])
+            supply_line_desc = "In Transit Shipments"
         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 is {echelon_state['inventory'] - echelon_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."
+
     elif llm_personality == 'human_like' and info_sharing == 'full':
         full_info_str = f"\n**Full Supply Chain Information:**\n- End-Customer Demand this week: {get_customer_demand(week)} units.\n"
         for name, e_state in all_echelons_state.items():
@@ -167,6 +175,7 @@ def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sh
         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 {echelon_state['name']}.** You have a limited view and tend to over-correct based on fear.
@@ -184,14 +193,14 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
     llm_personality, info_sharing = state['llm_personality'], state['info_sharing']
     echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     llm_raw_responses = {}
-
+    
     # Store pre-step state for logging
     pre_step_inventory = echelons[human_role]['inventory']
     pre_step_backlog = echelons[human_role]['backlog']
-    # Store arriving shipment amount *before* it's added to inventory
     arriving_shipment_this_week = list(echelons[human_role]['incoming_shipments'])[0] if echelons[human_role]['incoming_shipments'] else 0
 
-    # --- Game Simulation Steps ---
+    # --- Game Simulation Steps (Corrected Logic for Order Passing Delay = 1) ---
+
     # Step 1a: Factory Production completes and adds to Factory inventory
     factory_state = echelons["Factory"]
     produced_units = 0
@@ -206,16 +215,19 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
             arrived_shipment = echelons[name]['incoming_shipments'].popleft() # Pop shipment for current week
             echelons[name]['inventory'] += arrived_shipment
 
-    # Step 2: Orders arrive from downstream partners
+    # Step 2: Orders arrive from downstream partners (using LAST week's placed order)
     for name in echelon_order:
         if name == "Retailer":
             echelons[name]['incoming_order'] = get_customer_demand(week)
         else:
-            downstream = echelons[name]['downstream_name']
-            order_from_downstream = 0
-            if downstream and echelons[downstream]['order_pipeline']:
-                order_from_downstream = echelons[downstream]['order_pipeline'].popleft()
-            echelons[name]['incoming_order'] = order_from_downstream
+            # Get the downstream partner's name
+            downstream_name = echelons[name]['downstream_name']
+            if downstream_name:
+                # Retrieve the order placed by the downstream partner LAST week
+                order_from_downstream = state['last_week_orders'].get(downstream_name, 0)
+                echelons[name]['incoming_order'] = order_from_downstream
+            else: # Should not happen except maybe week 1 if not handled
+                 echelons[name]['incoming_order'] = 0
 
     # Step 3: Fulfill orders (Ship Beer)
     for name in echelon_order:
@@ -230,9 +242,11 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
         sender = echelons[sender_name]
         receiver_name = sender['downstream_name']
         if receiver_name:
+            # Append the shipment SENT this week to the receiver's incoming queue for the FUTURE
             echelons[receiver_name]['incoming_shipments'].append(sender['shipment_sent'])
 
     # --- Step 4: Agent Decisions (Place Orders / Schedule Production) ---
+    current_week_orders = {} # Store this week's decisions
     for name in echelon_order:
         e = echelons[name]
         if name == human_role:
@@ -242,95 +256,75 @@ 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) # This is the order/production decision for the week
-
-        # Place the order into the *end* of the current player's own order pipeline (for upstream player to receive later)
-        if name != "Factory":
-            e['order_pipeline'].append(e['order_placed'])
+        current_week_orders[name] = e['order_placed'] # Store decision for next week's Step 2
 
     # Factory schedules production based on its 'order_placed' decision
     state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
 
     # --- Logging (End of Week) ---
     log_entry = {'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week, **state}
-    # Remove complex objects before logging
-    del log_entry['echelons'], log_entry['factory_production_pipeline'], log_entry['logs']
+    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]
-        # Calculate costs based on inventory/backlog AFTER shipping step
         e['weekly_cost'] = (e['inventory'] * HOLDING_COST) + (e['backlog'] * BACKLOG_COST); e['total_cost'] += e['weekly_cost']
-
-        # Log core metrics (state at the END of the week)
         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, "")
-
-        # *** Explicitly log the value for 'Arriving Next Week' ***
-        # This reads the state of the queues *after* all steps for the week are done.
         if name != 'Factory':
-             # The next item in incoming_shipments is what arrives at the start of next week
              log_entry[f'{name}.arriving_next_week'] = list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0
         else:
-             # For factory, log what completes production next week
              log_entry[f'{name}.production_completing_next_week'] = list(state['factory_production_pipeline'])[0] if state['factory_production_pipeline'] else 0
 
-    # Log human-specific metrics recorded DURING the week
     log_entry[f'{human_role}.opening_inventory'] = pre_step_inventory
     log_entry[f'{human_role}.opening_backlog'] = pre_step_backlog
-    log_entry[f'{human_role}.arrived_this_week'] = arriving_shipment_this_week # Log the shipment that arrived in Step 1
-    log_entry[f'{human_role}.initial_order'] = human_initial_order # Log Step 4a decision
-    log_entry[f'{human_role}.ai_suggestion'] = ai_suggestion # Log Step 4b suggestion
+    log_entry[f'{human_role}.arrived_this_week'] = arriving_shipment_this_week
+    log_entry[f'{human_role}.initial_order'] = human_initial_order
+    log_entry[f'{human_role}.ai_suggestion'] = ai_suggestion
 
     state['logs'].append(log_entry)
 
     # --- Advance Week ---
     state['week'] += 1
     state['decision_step'] = 'initial_order'
+    state['last_week_orders'] = current_week_orders # Store current decisions for next week
     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))
     fig.suptitle(title, fontsize=16)
     echelons = ['Retailer', 'Wholesaler', 'Distributor', 'Factory']
-
     plot_data = []
     for _, row in df.iterrows():
         for e in echelons:
-            # Safely access keys, provide default if missing (e.g., first few weeks)
             plot_data.append({'week': row.get('week', 0), 'echelon': e,
                 'inventory': row.get(f'{e}.inventory', 0),
                 'order_placed': row.get(f'{e}.order_placed', 0),
                 'total_cost': row.get(f'{e}.total_cost', 0)})
     plot_df = pd.DataFrame(plot_data)
-
     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'); 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 (The Bullwhip Effect)'); axes[1].grid(True, linestyle='--'); axes[1].legend(); axes[1].set_ylabel('Ordered (Units)')
-
-    # Ensure total_cost calculation handles potential missing data gracefully
-    total_costs = plot_df.loc[plot_df.groupby('echelon')['week'].idxmax()] # Get row with max week for each echelon
+    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 ($)')
-
-    # 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
+    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:
         axes[3].set_title(f'Analysis of Your ({human_role}) Decisions - No Data'); axes[3].grid(True, linestyle='--'); axes[3].set_xlabel('Week')
-
-
     plt.tight_layout(rect=[0, 0, 1, 0.96]); return fig
 
 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'])
@@ -348,7 +342,7 @@ def save_logs_and_upload(state: dict):
                 st.error(f"Upload to Hugging Face failed: {e}")
 
 # -----------------------------------------------------------------------------
-# 4. Streamlit UI
+# 4. Streamlit UI (No changes needed in this section)
 # -----------------------------------------------------------------------------
 st.title("🍺 The Beer Game: A Human-AI Collaboration Challenge")
 
@@ -369,7 +363,7 @@ else:
         - **Holding Inventory:** **${HOLDING_COST:,.2f} per unit per week.
         - **Backlog (Unfilled Orders):** **${BACKLOG_COST:,.2f} per unit per week.
         """)
-
+        
         st.subheader("2. Your Role: The Distributor")
         st.markdown("""
         You will always play as the **Distributor**. The other 3 roles are played by AI.
@@ -392,13 +386,13 @@ else:
             * **Week 13 (System):** The 50 units *arrive* at your warehouse. (This is the **{FACTORY_SHIPPING_DELAY} week Shipping Delay**). You can now use this inventory.
             **Conclusion:** You must always think 3 weeks ahead. The order you place in Week 10 will not help you until Week 13.
             """)
-
+    
         st.subheader("4. How Each Week Works (Your Task)")
         st.markdown(f"""
         Your main job is simple: place one order each week.
         **A) At the start of every week, the system automatically does 3 things:**
         * **(Step 1) Your Shipments Arrive:** The beer you ordered {ORDER_PASSING_DELAY + FACTORY_LEAD_TIME + FACTORY_SHIPPING_DELAY} weeks ago arrives and is added to your `Current Inventory`.
-        * **(Step 2) New Orders Arrive:** You receive a new `Incoming Order` from the Wholesaler.
+        * **(Step 2) New Orders Arrive:** You receive a new `Incoming Order` from the Wholesaler (This was their order from *last* week).
         * **(Step 3) You Ship Beer:** The system automatically ships as much beer as possible from your inventory to fulfill the Wholesaler's order (plus any old `Backlog`).
         **B) After this, you will see your new dashboard and must make your 2-part decision:**
         * **Step 4a (Initial Order):** Based on your new status, submit your **initial order** to the Factory.
@@ -459,7 +453,9 @@ else:
         if state['decision_step'] == 'initial_order':
             with st.form(key="initial_order_form"):
                 st.markdown("#### **Step 4a:** Based on the information available, submit your **initial** order.")
-                initial_order = st.number_input("Your Initial Order Quantity:", min_value=0, step=1, value=human_echelon_state['incoming_order'])
+                # Default initial order to incoming order, or 4 if incoming is 0 initially
+                default_initial = human_echelon_state['incoming_order'] if human_echelon_state['incoming_order'] > 0 else 4
+                initial_order = st.number_input("Your Initial Order Quantity:", min_value=0, step=1, value=default_initial)
                 if st.form_submit_button("Submit Initial Order & See AI Suggestion", type="primary"):
                     state['human_initial_order'] = int(initial_order)
                     state['decision_step'] = 'final_order'
@@ -484,57 +480,36 @@ else:
                     st.rerun()
 
         st.markdown("---")
-        # =============== CORRECTED LOG DISPLAY BLOCK ===============
         with st.expander("📖 Your Weekly Decision Log", expanded=False):
-            if not state.get('logs'): # Use .get() for safety
+            if not state.get('logs'):
                 st.write("Your weekly history will be displayed here after you complete the first week.")
             else:
-                try: # Add error handling for data processing
+                try:
                     history_df = pd.json_normalize(state['logs'])
-
-                    # Define all desired columns and their display names
                     human_cols = {
-                        'week': 'Week',
-                        f'{human_role}.opening_inventory': 'Opening Inv.',
-                        f'{human_role}.opening_backlog': 'Opening Backlog',
-                        f'{human_role}.arrived_this_week': 'Arrived This Week', # Shipment that arrived at Step 1
-                        f'{human_role}.incoming_order': 'Incoming Order', # Order received at Step 2
-                        f'{human_role}.initial_order': 'Your Initial Order', # Step 4a
-                        f'{human_role}.ai_suggestion': 'AI Suggestion', # Step 4b
-                        f'{human_role}.order_placed': 'Your Final Order', # Step 4b (Order for Week+3)
-                        f'{human_role}.arriving_next_week': 'Arriving Next Week', # What will arrive in Step 1 of NEXT week
-                        f'{human_role}.weekly_cost': 'Weekly Cost', # Calculated at end of week
+                        'week': 'Week', f'{human_role}.opening_inventory': 'Opening Inv.',
+                        f'{human_role}.opening_backlog': 'Opening Backlog', f'{human_role}.arrived_this_week': 'Arrived This Week',
+                        f'{human_role}.incoming_order': 'Incoming Order', f'{human_role}.initial_order': 'Your Initial Order',
+                        f'{human_role}.ai_suggestion': 'AI Suggestion', f'{human_role}.order_placed': 'Your Final Order',
+                        f'{human_role}.arriving_next_week': 'Arriving Next Week', f'{human_role}.weekly_cost': 'Weekly Cost',
                     }
-
-                    # Define the desired order of columns
                     ordered_display_cols_keys = [
                         'week', f'{human_role}.opening_inventory', f'{human_role}.opening_backlog',
                         f'{human_role}.arrived_this_week', f'{human_role}.incoming_order',
                         f'{human_role}.initial_order', f'{human_role}.ai_suggestion', f'{human_role}.order_placed',
                         f'{human_role}.arriving_next_week', f'{human_role}.weekly_cost'
                      ]
-
-                    # Filter the desired columns based on what actually exists in the log data
                     final_cols_to_display = [col for col in ordered_display_cols_keys if col in history_df.columns]
 
                     if not final_cols_to_display:
                          st.write("No data columns available to display.")
                     else:
-                        # Select and rename the columns that exist
                         display_df = history_df[final_cols_to_display].rename(columns=human_cols)
-
-                        # Format the cost column
                         if 'Weekly Cost' in display_df.columns:
-                            # Apply formatting safely, 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 "")
-
-                        # Display the dataframe
                         st.dataframe(display_df.sort_values(by="Week", ascending=False), hide_index=True, use_container_width=True)
-
                 except Exception as e:
                     st.error(f"Error displaying weekly log: {e}")
-                    st.write("Log data structure might be inconsistent.")
-        # =======================================================
 
         try: st.sidebar.image(IMAGE_PATH, caption="Supply Chain Reference")
         except FileNotFoundError: st.sidebar.warning("Image file not found.")
@@ -550,7 +525,7 @@ else:
     if 'game_state' in st.session_state and not st.session_state.game_state.get('game_running', False) and st.session_state.game_state['week'] > WEEKS:
         st.header("🎉 Game Over!")
         state = st.session_state.game_state
-        try: # Add error handling for final plot/save
+        try:
             logs_df = pd.json_normalize(state['logs'])
             fig = plot_results(
                 logs_df,
@@ -561,7 +536,6 @@ else:
             save_logs_and_upload(state)
         except Exception as e:
             st.error(f"Error generating final report: {e}")
-            st.write("Log data might be corrupted or incomplete.")
 
         if st.button("✨ Start a New Game"):
             del st.session_state.game_state