Keep invalid-action task scores inside open interval

server/environment.py

@@ -196,8 +196,9 @@ class HelpdeskTicketRoutingEnvironment(
         allowed = set(task["allowed_fields"])
         extra_fields = submitted_fields - allowed
         if extra_fields:
-            # Penalty: record score 0.0, advance index, return penalty observation
-            self._state.per_ticket_scores.append(0.0)
+            # Penalty: record an open-interval score, advance index, return penalty observation
+            invalid_score = clamp_open_unit_interval(0.0)
+            self._state.per_ticket_scores.append(invalid_score)
             self._state.average_score_so_far = self._current_average_score()
             self._state.step_count += 1
             self._state.current_ticket_index += 1
@@ -219,7 +220,7 @@ class HelpdeskTicketRoutingEnvironment(
             else:
                 final_reward = 0.0
             reward_components = self._build_reward_components(
-                ticket_score=0.0,
+                ticket_score=invalid_score,
                 field_breakdown={},
                 shaped_step_reward=0.0,
                 reward_kind="trajectory" if is_done else "step_penalty",
@@ -249,7 +250,7 @@ class HelpdeskTicketRoutingEnvironment(
                 self._build_history_entry(
                     current_ticket,
                     predicted=action.model_dump(exclude_none=True),
-                    score=0.0,
+                    score=invalid_score,
                     breakdown={},
                     queue_position=idx + 1,
                     reward=final_reward,

tests/test_competitive_upgrade.py

@@ -746,9 +746,9 @@ class TestTerminalInvalidActionFinalReward(unittest.TestCase):
         )
 
         self.assertTrue(final_obs.done)
-        self.assertAlmostEqual(final_obs.reward, 0.4995, places=9)
-        self.assertAlmostEqual(env.state.total_reward, 0.4995, places=9)
-        self.assertAlmostEqual(env.state.reward or 0.0, 0.4995, places=9)
+        self.assertAlmostEqual(final_obs.reward, 0.5, places=9)
+        self.assertAlmostEqual(env.state.total_reward, 0.5, places=9)
+        self.assertAlmostEqual(env.state.reward or 0.0, 0.5, places=9)
 
 
 # ---------------------------------------------------------------------------

tests/test_extra_fields_penalty.py

@@ -77,8 +77,8 @@ class TestExtraFieldsPenalty(unittest.TestCase):
 
         self.assertEqual(penalty_obs.tickets_processed, 1)
 
-    def test_extra_fields_records_score_zero(self) -> None:
-        """per_ticket_scores must contain 0.0 after a penalty step."""
+    def test_extra_fields_records_score_inside_open_interval(self) -> None:
+        """per_ticket_scores must stay in the open interval after a penalty step."""
         env = _make_env()
         env.reset(seed=42, task_id=1)
 
@@ -90,7 +90,8 @@ class TestExtraFieldsPenalty(unittest.TestCase):
 
         state = env.state
         self.assertEqual(len(state.per_ticket_scores), 1)
-        self.assertEqual(state.per_ticket_scores[0], 0.0)
+        self.assertGreater(state.per_ticket_scores[0], 0.0)
+        self.assertLess(state.per_ticket_scores[0], 1.0)
 
     def test_extra_fields_history_entry_has_penalty_reason(self) -> None:
         """History entry for a penalty step must include penalty_reason."""
@@ -107,7 +108,8 @@ class TestExtraFieldsPenalty(unittest.TestCase):
         entry = penalty_obs.history[0]
         self.assertIn("penalty_reason", entry)
         self.assertIn("assignment_group", entry["penalty_reason"])
-        self.assertEqual(entry["score"], 0.0)
+        self.assertGreater(entry["score"], 0.0)
+        self.assertLess(entry["score"], 1.0)
 
     def test_no_extra_fields_grades_normally(self) -> None:
         """When action fields are within allowed_fields, grading proceeds normally (reward != forced 0.0)."""
@@ -191,9 +193,10 @@ class TestExtraFieldsPenalty(unittest.TestCase):
         final_obs = env.step(action)
 
         self.assertTrue(final_obs.done)
-        expected_reward = (queue_size - 1) / queue_size
-        self.assertAlmostEqual(final_obs.reward, expected_reward, places=9)
-        self.assertAlmostEqual(env.state.total_reward, expected_reward, places=9)
+        self.assertGreater(final_obs.reward, 0.0)
+        self.assertLess(final_obs.reward, 1.0)
+        self.assertGreater(env.state.total_reward, 0.0)
+        self.assertLess(env.state.total_reward, 1.0)
 
 
 if __name__ == "__main__":