Defensive score clamping at all emission points

Every reward/score emitted by inference.py is now clamped to [0.05, 0.95]
via _clamp_score() before logging. This closes multiple paths that could
leak exact 0.0 or 1.0:

- Initial score default was 0.0 (would emit on early reset failure)
- Exception path logged reward=0.0 and appended 0.0 to rewards list
- env.reset() failure wasn't wrapped in its own try/except

Also bumped grade_response epsilon from 0.01 to 0.05 and aligned
openenv.yaml reward.range to [0.0, 1.0].

backend/env/tasks.py

@@ -330,7 +330,7 @@ def get_all_tasks() -> list[Task]:
     return list(TASKS.values())
 
 
-_EPS = 0.01  # wide enough that f"{x:.3f}" never rounds to 0.000 or 1.000
+_EPS = 0.05  # wide margin so :.2f/:.3f never rounds to 0.00 or 1.00
 
 
 def grade_response(

inference.py

@@ -152,6 +152,16 @@ def pick_action(
 
 # ── Single-episode runner ─────────────────────────────────────────────────────
 
+_SCORE_EPS = 0.05  # strict (0, 1) with generous margin for :.2f/:.3f rounding
+
+
+def _clamp_score(x: float) -> float:
+    """Clamp to strictly (0, 1). Uses 0.05 margin so :.2f/:.3f formatting stays safe."""
+    if x != x:  # NaN
+        return 0.5
+    return max(_SCORE_EPS, min(1.0 - _SCORE_EPS, x))
+
+
 async def run_episode(
     env: SQLAgentEnv,
     client: OpenAI,
@@ -162,12 +172,18 @@ async def run_episode(
 
     rewards: List[float] = []
     steps_taken = 0
-    score = 0.0
+    score = _SCORE_EPS
     success = False
     last_error: Optional[str] = None
 
     try:
-        obs = env.reset(task_id)
+        try:
+            obs = env.reset(task_id)
+        except Exception as exc:
+            log_step(step=1, action="reset", reward=_SCORE_EPS, done=True, error=str(exc))
+            rewards.append(_SCORE_EPS)
+            steps_taken = 1
+            return
 
         for step in range(1, MAX_STEPS + 1):
             action_name = pick_action(client, obs, step)
@@ -175,13 +191,14 @@ async def run_episode(
 
             try:
                 obs, reward_info = await env.step(action)
-            except RuntimeError as exc:
-                log_step(step=step, action=action_name, reward=0.0, done=True, error=str(exc))
-                rewards.append(0.0)
+            except Exception as exc:
+                log_step(step=step, action=action_name, reward=_SCORE_EPS, done=True, error=str(exc))
+                rewards.append(_SCORE_EPS)
                 steps_taken = step
                 break
 
-            reward = reward_info.value
+            raw_reward = reward_info.value if reward_info.value is not None else _SCORE_EPS
+            reward = _clamp_score(raw_reward)
             done = reward_info.done
             last_error = obs.error_message
             success = reward_info.success
@@ -200,14 +217,14 @@ async def run_episode(
             if done:
                 break
 
-        # Score: average of per-step rewards. Clamp strictly inside (0, 1)
-        # with margin >= 0.005 so f"{score:.3f}" never formats to "0.000" or "1.000".
-        _EPS = 0.01
         denom = max(len(rewards), 1)
-        avg = sum(rewards) / denom if rewards else _EPS
-        score = max(_EPS, min(1.0 - _EPS, avg))
+        avg = sum(rewards) / denom if rewards else _SCORE_EPS
+        score = _clamp_score(avg)
 
     finally:
+        # Final safety net: score and every reward must be strictly in (0, 1)
+        score = _clamp_score(score)
+        rewards = [_clamp_score(r) for r in rewards]
         log_end(
             success=success,
             steps=steps_taken,

openenv.yaml

@@ -82,12 +82,11 @@ observation_space:
 
 # ── Reward ───────────────────────────────────────────────────────────────────
 reward:
-  range: [-1.5, 1.5]
+  range: [0.0, 1.0]
   description: >
-    Shaped reward providing partial progress signals throughout the episode.
-    Success on attempt N: 1.0 - 0.1*(N-1).
-    Failure step: -0.1 - 0.05*N + severity_improvement_bonus + error_class_change_bonus.
-    Penalizes infinite loops (consecutive same error) and rewards convergence toward correct SQL.
+    Task score is the grader output clamped strictly inside (0, 1). Graders
+    score partial progress (column correctness, row-count match) and apply
+    attempt penalties for multi-step repair episodes.
 
 # ── Tasks ────────────────────────────────────────────────────────────────────
 tasks: