Update main.py

main.py

@@ -182,14 +182,17 @@ async def select_and_activate_new_agent():
 
 async def check_for_new_battle():
     """Checks if the active agent has started a battle with a valid tag."""
-    global active_agent_instance, current_battle_instance
+    # --- FIX: Declare intention to use/modify global variables ---
+    global active_agent_instance, current_battle_instance, active_agent_name, active_agent_task
+    # -------------------------------------------------------------
 
     if active_agent_instance:
         battle = get_active_battle(active_agent_instance)
         # Check if battle exists AND has a valid battle_tag
         if battle and battle.battle_tag:
-            print(f"Lifecycle: Agent '{active_agent_name}' started battle: {battle.battle_tag}")
+            # This line MODIFIES the global variable
             current_battle_instance = battle
+            print(f"Lifecycle: Agent '{active_agent_name}' started battle: {battle.battle_tag}")
 
             # Stop the agent from listening for more challenges once a battle starts
             if active_agent_task and not active_agent_task.done():
@@ -203,7 +206,6 @@ async def check_for_new_battle():
         # else:
             # print(f"DEBUG: get_active_battle returned None or battle without tag.")
 
-
 async def deactivate_current_agent(reason: str = "cycle"):
     """Cleans up the currently active agent and resets state."""
     global active_agent_name, active_agent_instance, active_agent_task, current_battle_instance
@@ -279,10 +281,11 @@ async def deactivate_current_agent(reason: str = "cycle"):
     await asyncio.sleep(2) # Reduced from 3, adjust as needed
     print(f"Lifecycle: Agent '{agent_name_to_deactivate}' deactivation complete.")
 
-# --- Main Background Task ---
 async def manage_agent_lifecycle():
     """Runs the main loop selecting, running, and cleaning up agents sequentially."""
-    global active_agent_instance, active_agent_task, current_battle_instance
+    # --- FIX: Declare intention to use global variables ---
+    global active_agent_name, active_agent_instance, active_agent_task, current_battle_instance
+    # ------------------------------------------------------
 
     print("Background lifecycle manager started.")
     REFRESH_INTERVAL_SECONDS = 3 # How often to check state when idle/in battle
@@ -301,6 +304,7 @@ async def manage_agent_lifecycle():
             # ==================================
             # State 1: No agent active
             # ==================================
+            # Now Python knows active_agent_instance refers to the global one
             if active_agent_instance is None:
                 print(f"[{loop_counter}] State 1: No active agent. Selecting...")
                 activated = await select_and_activate_new_agent()
@@ -308,6 +312,7 @@ async def manage_agent_lifecycle():
                     print(f"[{loop_counter}] State 1: Activation failed. Waiting {ERROR_RETRY_DELAY_SECONDS}s before retry.")
                     await asyncio.sleep(ERROR_RETRY_DELAY_SECONDS)
                 else:
+                    # Now Python knows active_agent_name refers to the global one set by select_and_activate_new_agent
                     print(f"[{loop_counter}] State 1: Agent '{active_agent_name}' activated successfully.")
                     # No sleep here, proceed to next check immediately if needed
 
@@ -315,14 +320,17 @@ async def manage_agent_lifecycle():
             # State 2: Agent is active
             # ==================================
             else:
+                # Now Python knows active_agent_name refers to the global one
                 agent_name = active_agent_name # Cache for logging
                 print(f"[{loop_counter}] State 2: Agent '{agent_name}' is active.")
 
                 # --- Sub-state: Check for new battle if none is tracked ---
+                # Now Python knows current_battle_instance refers to the global one
                 if current_battle_instance is None:
                     print(f"[{loop_counter}] State 2a: Checking for new battle for '{agent_name}'...")
-                    await check_for_new_battle() # This updates current_battle_instance if found
+                    await check_for_new_battle() # This updates global current_battle_instance if found
 
+                    # Now Python knows current_battle_instance refers to the global one
                     if current_battle_instance:
                         battle_tag = current_battle_instance.battle_tag
                         print(f"[{loop_counter}] State 2a: *** NEW BATTLE DETECTED: {battle_tag} for '{agent_name}' ***")
@@ -336,6 +344,7 @@ async def manage_agent_lifecycle():
                             print(f"[{loop_counter}] Detected potentially non-public battle format ({battle_tag}). Forfeiting.")
                             # Don't update display yet, do it before deactivation
                             try:
+                                # Now Python knows active_agent_instance refers to the global one
                                 if active_agent_instance: # Ensure agent still exists
                                     await active_agent_instance.forfeit(battle_tag)
                                     # await active_agent_instance.send_message("/forfeit", battle_tag) # Alternative
@@ -364,11 +373,13 @@ async def manage_agent_lifecycle():
 
 
                 # --- Sub-state: Monitor ongoing battle ---
+                 # Now Python knows current_battle_instance refers to the global one
                 if current_battle_instance is not None:
                     battle_tag = current_battle_instance.battle_tag
                     print(f"[{loop_counter}] State 2b: Monitoring battle {battle_tag} for '{agent_name}'")
 
                     # Ensure agent instance still exists before accessing its battles
+                    # Now Python knows active_agent_instance refers to the global one
                     if not active_agent_instance:
                         print(f"[{loop_counter}] WARNING: Agent instance for '{agent_name}' disappeared while monitoring battle {battle_tag}! Deactivating.")
                         await deactivate_current_agent(reason="agent_disappeared_mid_battle")
@@ -376,6 +387,7 @@ async def manage_agent_lifecycle():
 
                     # Get potentially updated battle object directly from agent's state
                     # Use .get() for safety
+                    # Now Python knows active_agent_instance refers to the global one
                     battle_obj = active_agent_instance._battles.get(battle_tag)
 
                     if battle_obj and battle_obj.finished:
@@ -405,7 +417,9 @@ async def manage_agent_lifecycle():
         except Exception as e:
             print(f"!!! ERROR in main lifecycle loop #{loop_counter}: {e} !!!")
             traceback.print_exc()
+             # Now Python knows active_agent_name refers to the global one
             current_agent_name = active_agent_name # Cache name before deactivation attempts
+            # Now Python knows active_agent_instance refers to the global one
             if active_agent_instance:
                 print(f"Attempting to deactivate agent '{current_agent_name}' due to loop error...")
                 try:
@@ -433,7 +447,6 @@ async def manage_agent_lifecycle():
         if elapsed_time < LOOP_COOLDOWN_SECONDS:
              await asyncio.sleep(LOOP_COOLDOWN_SECONDS - elapsed_time)
 
-
 def log_task_exception(task: asyncio.Task):
     """Callback to log exceptions from background tasks (like accept_challenges)."""
     try: