Run all tasks by default and keep task scores inside open interval

inference.py

@@ -307,12 +307,14 @@ def get_tasks_to_run(available_tasks: dict) -> list[int]:
             )
             raise SystemExit(1)
         return [task_id]
-    if RUN_ALL_TASKS_ENV:
-        return available_task_ids
     if not available_task_ids:
         return []
-    # Default to a single task so evaluation emits exactly one START/END block.
-    return [available_task_ids[0]]
+    # Default to all declared tasks so validator-style runs exercise all graders.
+    return available_task_ids
+
+
+def clamp_reported_score(score: float) -> float:
+    return max(0.001, min(0.999, score))
 
 
 # ---------------------------------------------------------------------------
@@ -852,8 +854,6 @@ def run() -> None:
     tasks_to_run = get_tasks_to_run(available_tasks)
     if not tasks_to_run:
         return
-    single_task_mode = len(tasks_to_run) == 1
-
     for task_id in tasks_to_run:
         if task_id not in available_tasks:
             continue
@@ -952,20 +952,12 @@ def run() -> None:
         emit_log(
             "END",
             final_reward=round(final_reward, 4),
+            score=round(clamp_reported_score(final_reward), 4),
             step_count=step_num,
             task_id=task_id,
             task_name=task["name"],
         )
 
-    overall = [
-        float(all_results[task_id]["final_reward"])
-        for task_id in tasks_to_run
-        if task_id in all_results
-    ]
-    if not single_task_mode:
-        overall_avg = round(sum(overall) / len(overall), 4) if overall else 0.0
-        emit_log("END", overall_avg=overall_avg, tasks_completed=len(overall))
-
 
 if __name__ == "__main__":
     run()

server/environment.py

@@ -14,6 +14,7 @@ from models import (
 )
 from server.grader import grade_action
 from server.reward import (
+    clamp_open_unit_interval,
     compute_step_adjustments,
     compute_trajectory_adjustments,
 )
@@ -310,7 +311,7 @@ class HelpdeskTicketRoutingEnvironment(
             )
             trajectory_reward = trajectory_components["final_reward"]
             rubric_reward = self._apply_episode_economics(trajectory_reward)
-            final_reward = max(0.0, min(1.0, rubric_reward - context_penalty))
+            final_reward = clamp_open_unit_interval(rubric_reward - context_penalty)
             self._state.total_reward = rubric_reward
             investigation_penalty = self._compute_episode_penalty()
         else:
@@ -403,7 +404,7 @@ class HelpdeskTicketRoutingEnvironment(
 
     def _apply_episode_economics(self, base_reward: float) -> float:
         penalty = self._compute_episode_penalty()
-        return max(0.0, min(1.0, base_reward - penalty))
+        return clamp_open_unit_interval(base_reward - penalty)
 
     def _current_average_score(self) -> float:
         if not self._state.per_ticket_scores:

server/reward.py

@@ -8,12 +8,17 @@ DELTA_REWARD_WEIGHT = 0.08
 DELTA_REWARD_CAP = 0.04
 PROCESS_BONUS_CAP = 0.08
 RISK_PENALTY_CAP = 0.12
+OPEN_INTERVAL_EPSILON = 0.001
 
 
 def _clamp_unit_interval(value: float) -> float:
     return max(0.0, min(1.0, value))
 
 
+def clamp_open_unit_interval(value: float, epsilon: float = OPEN_INTERVAL_EPSILON) -> float:
+    return max(epsilon, min(1.0 - epsilon, value))
+
+
 def compute_step_adjustments(
     score: float,
     *,
@@ -88,7 +93,7 @@ def compute_trajectory_adjustments(
     avg = sum(per_ticket_scores) / len(per_ticket_scores)
     bounded_completion_bonus = max(0.0, min(0.08, completion_bonus))
     bounded_consistency_bonus = max(0.0, min(0.05, consistency_bonus))
-    final_reward = _clamp_unit_interval(
+    final_reward = clamp_open_unit_interval(
         avg + bounded_completion_bonus + bounded_consistency_bonus
     )
     return {

tests/test_competitive_upgrade.py

@@ -710,7 +710,7 @@ class TestQueueEconomics(unittest.TestCase):
         final_obs = env.step(HelpdeskTicketAction(issue_type=ticket.issue_type))
 
         self.assertTrue(final_obs.done)
-        self.assertAlmostEqual(final_obs.reward, 0.98, places=9)
+        self.assertAlmostEqual(final_obs.reward, 0.979, places=9)
 
 
 class TestTerminalInvalidActionFinalReward(unittest.TestCase):

tests/test_inference_unit.py

@@ -187,7 +187,7 @@ class InferenceUnitTests(unittest.TestCase):
 
         self.assertEqual(
             inference.get_tasks_to_run({1: {}, 2: {}, 3: {}}),
-            [1],
+            [1, 2, 3],
         )
 
     def test_run_all_tasks_override_keeps_local_batch_mode_available(self) -> None: