director: never crash the fight on a 503 or a stale lane

Guard the LLM call in _choose (backend failure -> deterministic rng pick) and re-resolve the target lane against current state in _apply with an IllegalMove backstop. Fixes two worker crashes seen on the Space: HTTPStatusError 503 from ZeroGPU under load, and IllegalMove when the player empties the targeted lane during the slow director await.

scrypt/warden/director.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import random
 from dataclasses import dataclass, field
 
-from scrypt.engine.combat import LANES, CombatState
+from scrypt.engine.combat import LANES, CombatState, IllegalMove
 from scrypt.inference.backend import Backend
 
 from .context import build_messages, combat_digest
@@ -129,34 +129,72 @@ class Director:
             'by calling the tool. Pick what stings most.'
         )
         harness = Harness(self.backend, [tool], max_steps=2, max_tokens=120)
-        await harness.run(build_messages(frame, digest=combat_digest(state)))
+        try:
+            await harness.run(build_messages(frame, digest=combat_digest(state)))
+        except Exception:
+            # A dead/slow/rude backend (e.g. the Space's ZeroGPU returning 503)
+            # must never crash the fight: fall back to a deterministic pick,
+            # exactly as author.compose and the voice path do.
+            return self.rng.choice(names)
         return picked[0] if picked else self.rng.choice(names)
 
     # ------------------------------------------------------------ applying
 
-    def _apply(self, state: CombatState, action: str, args: dict) -> Intervention:
+    _NOOP = Intervention("none", "no-op", "")
+
+    def _resolve_lane(self, state: CombatState, action: str) -> int | None:
+        """Re-pick a legal target lane from CURRENT state. The lane chosen in
+        _legal_options was validated BEFORE the (slow) LLM await; the player
+        keeps acting during it, so by now that lane may be empty/occupied.
+        Re-deriving here keeps the intervention real instead of crashing on a
+        stale index. None = nothing legal remains for this action."""
         if action == "throttle":
-            if self.budget.try_spend("tamper_player_deck"):
-                detail = state.throttle_player_card(args["lane"])
-                card = state.player_row[args["lane"]].spec.id
+            lanes = [
+                i for i in range(LANES)
+                if state.player_row[i] is not None and state.player_row[i].power > 0
+            ]
+            return max(lanes, key=lambda i: state.player_row[i].power) if lanes else None
+        if action == "reinforce":
+            empty = [i for i in range(LANES) if state.foe_queue[i] is None]
+            return self.rng.choice(empty) if empty else None
+        if action == "withdraw":
+            queued = [
+                i for i in range(LANES)
+                if state.foe_queue[i] is not None and state.foe_queue[i].power >= 2
+            ]
+            return max(queued, key=lambda i: state.foe_queue[i].power) if queued else None
+        return None
+
+    def _apply(self, state: CombatState, action: str, args: dict) -> Intervention:
+        lane = self._resolve_lane(state, action)
+        if lane is None:
+            return self._NOOP  # the board moved under us; nothing legal left
+        try:
+            if action == "throttle":
+                if not self.budget.try_spend("tamper_player_deck"):
+                    return self._NOOP
+                card = state.player_row[lane].spec.id
+                detail = state.throttle_player_card(lane)
                 return Intervention(
                     "throttle", detail,
                     f"you just quietly weakened the player's {card}; gloat without "
                     "explaining exactly what you did",
                 )
-        if action == "reinforce":
-            spec = self.content.card(args["card"])
-            detail = state.reinforce_queue(args["lane"], spec)
-            return Intervention(
-                "reinforce", detail,
-                f"you just scheduled an extra {spec.id} against the player",
-            )
-        if action == "withdraw":
-            detail = state.withdraw_queue(args["lane"])
-            return Intervention(
-                "withdraw", detail,
-                "you quietly removed a threat because the player is being crushed; "
-                "say something that sounds like boredom, not kindness",
-            )
-        # Budget refused late: report nothing happened.
-        return Intervention("none", "no-op", "")
+            if action == "reinforce":
+                spec = self.content.card(args["card"])
+                detail = state.reinforce_queue(lane, spec)
+                return Intervention(
+                    "reinforce", detail,
+                    f"you just scheduled an extra {spec.id} against the player",
+                )
+            if action == "withdraw":
+                detail = state.withdraw_queue(lane)
+                return Intervention(
+                    "withdraw", detail,
+                    "you quietly removed a threat because the player is being crushed; "
+                    "say something that sounds like boredom, not kindness",
+                )
+        except IllegalMove:
+            # Backstop: state changed between resolve and mutate. Never crash.
+            return self._NOOP
+        return self._NOOP