Harden strict (0,1) scoring boundaries across runtime and config.

Clamp reward outputs to non-boundary values, align schema ranges, and remove inference fallbacks that could emit 0.0 or 1.0 during evaluation.

ss:

inference.py

@@ -218,7 +218,7 @@ def run_task(
 
     rewards = []
     steps_taken = 0
-    score = 0.0
+    score = MIN_STRICT_SCORE
     success = False
 
     with httpx.Client(base_url=ENV_BASE_URL, timeout=30.0) as http:
@@ -245,11 +245,11 @@ def run_task(
                 step_resp.raise_for_status()
                 step_result = step_resp.json()
             except Exception as e:
-                log_step(step=step, action=str(action_dict), reward=0.0, done=False, error=str(e))
+                log_step(step=step, action=str(action_dict), reward=MIN_STRICT_SCORE, done=False, error=str(e))
                 continue
 
             obs = step_result["observation"]
-            reward = float(step_result.get("reward") or 0.0)
+            reward = float(step_result.get("reward") or MIN_STRICT_SCORE)
             done = step_result["done"]
             error = None
             info = step_result.get("info") or {}
@@ -264,7 +264,7 @@ def run_task(
             rewards.append(reward)
             reward_history.append(reward)
             steps_taken = step
-            score = float(info.get("grade_score") or obs.get("current_score") or 0.0)
+            score = float(info.get("grade_score") or obs.get("current_score") or MIN_STRICT_SCORE)
 
             log_step(step=step, action=action_str, reward=reward, done=done, error=error)
 

openenv.yaml

@@ -37,7 +37,7 @@ tasks:
     description: "Fix 5 bugs: correlated subquery, window function, duplicate rows, date logic, CTE scope"
 
 api:
-  base_url: "https://YOUR-USERNAME-sql-debug-env.hf.space"
+  base_url: "https://md896-sql-debug-env.hf.space"
   reset: "/reset"
   step: "/step"
   state: "/state"
@@ -77,7 +77,7 @@ action_space:
       description: "Reset to original broken query (penalty: -0.05)"
 
 reward:
-  range: [0.0, 1.0]
+  range: [0.001, 0.999]
   components:
     - name: correctness
       range: [0.0, 0.6]

server/models.py

@@ -86,7 +86,7 @@ class SQLDebugObservation(BaseModel):
     # Progress
     steps_taken: int
     steps_remaining: int
-    current_score: float = Field(description="Current score 0.0-1.0 for this episode")
+    current_score: float = Field(description="Current score in strict range (0, 1) for this episode")
 
     # Contextual help (populated based on action type)
     schema_info: Optional[SchemaInfo] = None
@@ -112,7 +112,7 @@ class SQLDebugReward(BaseModel):
     - schema_bonus: 0.0-0.1 for queries that reference correct tables/columns
     - penalties: negative values for reset_query, infinite loops, destructive SQL
     """
-    value: float = Field(ge=0.0, le=1.0, description="Total reward for this step")
+    value: float = Field(ge=0.001, le=0.999, description="Total reward for this step")
     correctness: float = Field(ge=0.0, le=0.6)
     efficiency: float = Field(ge=0.0, le=0.2)
     syntax_progress: float = Field(ge=0.0, le=0.1)

server/reward.py

@@ -16,6 +16,13 @@ Total range: 0.0 to 1.0 (clamped to [0.0, 1.0])
 from typing import Optional, List, Dict, Any
 from .models import SQLDebugReward
 
+MIN_STRICT_SCORE = 0.001
+MAX_STRICT_SCORE = 0.999
+
+
+def _strict_score(value: float) -> float:
+    return round(min(MAX_STRICT_SCORE, max(MIN_STRICT_SCORE, value)), 4)
+
 
 def compute_reward(
     action_type: str,
@@ -33,7 +40,7 @@ def compute_reward(
     Args:
     action_type: The action taken this step
     query_result: Result dict from EpisodeDatabase.execute_query()
-    grade_score: 0.0-1.0 score from task grader
+    grade_score: strict (0, 1) score from task grader
     steps_taken: How many steps have been used (1-indexed)
     max_steps: Maximum steps for this task
     previous_best_score: Best grade score seen so far
@@ -103,7 +110,7 @@ def compute_reward(
         penalty += 0.03
 
     total_raw = correctness + efficiency + syntax_progress + schema_bonus - penalty
-    total = round(max(0.0, min(1.0, total_raw)), 4)
+    total = _strict_score(total_raw)
 
     breakdown = (
         f"correctness={correctness:.3f} + "

tests/test_reward.py

@@ -8,42 +8,42 @@ class TestReward(unittest.TestCase):
         reward = compute_reward(
             action_type="submit_query",
             query_result={"success": True},
-            grade_score=1.0,
+            grade_score=0.999,
             steps_taken=1,
             max_steps=10,
-            previous_best_score=0.0,
+            previous_best_score=0.001,
             schema_tables=["t1", "t2"],
             submitted_query="SELECT * FROM t1 JOIN t2",
         )
-        self.assertAlmostEqual(reward.value, 1.0, places=4)
+        self.assertAlmostEqual(reward.value, 0.999, places=4)
 
     def test_reset_query_penalty(self):
         reward = compute_reward(
             action_type="reset_query",
             query_result=None,
-            grade_score=0.0,
+            grade_score=0.001,
             steps_taken=1,
             max_steps=10,
-            previous_best_score=0.0,
+            previous_best_score=0.001,
             schema_tables=[],
             submitted_query=None,
         )
-        self.assertAlmostEqual(reward.value, 0.0, places=4)
+        self.assertAlmostEqual(reward.value, 0.001, places=4)
 
     def test_inspect_schema_urgency_penalty(self):
         # Make steps_remaining <= 2 and grade_score < 0.5 to trigger urgency penalty.
         reward = compute_reward(
             action_type="inspect_schema",
             query_result=None,
-            grade_score=0.0,
+            grade_score=0.001,
             steps_taken=8,
             max_steps=9,
-            previous_best_score=0.0,
+            previous_best_score=0.001,
             schema_tables=[],
             submitted_query=None,
         )
-        # syntax_progress=0.01, penalty=0.03 => total_raw=-0.02, clamped to 0.0
-        self.assertAlmostEqual(reward.value, 0.0, places=4)
+        # syntax_progress=0.01, penalty=0.03 => total_raw=-0.02, clamped to strict min
+        self.assertAlmostEqual(reward.value, 0.001, places=4)
 
 
 if __name__ == "__main__":