B

README.md

@@ -66,18 +66,18 @@ wrong answer across steps.
 
 | Score | Condition |
 |-------|-----------|
-| `1.0` | Exact match after normalization (perfect fix) |
+| `0.99` | Exact match after normalization (perfect fix) |
 | `0.7` | All correct tokens present, structure slightly off |
 | `0.4` | Most keywords correct and token overlap is high (≥85% keywords, ≥75% tokens) |
 | `0.3` | Partial keyword and structure match (≥65% keywords, ≥50% tokens) |
 | `0.2` | Basic `SELECT ... FROM ...` structure present |
-| `0.0` | Response is not valid SQL |
+| `0.01` | Response is not valid SQL |
 
 A **stagnation penalty** of `−0.1` is applied when the agent submits the same
 reward-equivalent answer for two or more consecutive steps, encouraging active
 correction rather than looping.
 
-Episodes terminate when reward = 1.0 (success) or max steps is reached.
+Episodes terminate when reward reaches `0.99` (success) or max steps is reached.
 
 ---
 

openenv.yaml

@@ -76,15 +76,15 @@ action_space:
       type: string
 
 reward:
-  range: [0.0, 1.0]
+  range: [0.01, 0.99]
   description: >
-    1.0 = exact match, 0.7 = right tokens minor structure diff,
+    0.99 = exact match, 0.7 = right tokens minor structure diff,
     0.4 = most keywords correct, 0.3 = partial match,
-    0.2 = basic structure present, 0.0 = invalid SQL.
+    0.2 = basic structure present, 0.01 = invalid SQL.
     Stagnation penalty of -0.1 applied after 2+ identical-reward steps.
 
 scoring:
-  reward_range: [0.0, 1.0]
+  reward_range: [0.01, 0.99]
   success_threshold: 0.5
   score_formula: mean(step_rewards)
 

sql_env/env.py

@@ -33,7 +33,7 @@ class SQLCorrectionEnv:
         self._done: bool = False
         self._previous_attempt: Optional[str] = None
         self._last_feedback: Optional[str] = None
-        self._last_reward: float = 0.0
+        self._last_reward: float = 0.01
         self._stagnation_count: int = 0
 
     # ── OpenEnv Interface ─────────────────────────────────────────────────────
@@ -50,7 +50,7 @@ class SQLCorrectionEnv:
         self._done = False
         self._previous_attempt = None
         self._last_feedback = None
-        self._last_reward = 0.0
+        self._last_reward = 0.01
         self._stagnation_count = 0
 
         return self._make_observation()
@@ -77,14 +77,16 @@ class SQLCorrectionEnv:
                 reward = max(0.01, reward - 0.1)
         else:
             self._stagnation_count = 0
-
+        # Final Clamp
+        reward = max(0.01, min(0.98, reward))
+        
         self._last_reward = reward
 
         feedback = generate_feedback(action, self._task, reward_model)
         self._last_feedback = feedback
         self._previous_attempt = action.corrected_query
 
-        done = reward_model.value >= 0.95 or self._step_count >= self._task.max_steps
+        done = reward >= 0.95 or self._step_count >= self._task.max_steps
         self._done = done
 
         obs = self._make_observation()

sql_env/grader.py

@@ -34,7 +34,7 @@ def _sql_keywords_present(query: str) -> set:
 
 def _clamp(value: float) -> float:
     """Ensure reward is strictly within (0, 1) as required by the OpenEnv spec."""
-    return max(0.01, min(0.99, value))
+    return max(0.02, min(0.98, value))
 
 
 def grade(action: SQLAction, task: SQLTask) -> SQLReward:
@@ -55,7 +55,7 @@ def grade(action: SQLAction, task: SQLTask) -> SQLReward:
     # ── Level 1: Exact match ─────────────────────────────────────────────────
     if agent == correct:
         return SQLReward(
-            value=_clamp(0.99),
+            value=_clamp(0.98),
             reason="Exact match — perfect correction.",
         )
 
@@ -106,7 +106,7 @@ def grade(action: SQLAction, task: SQLTask) -> SQLReward:
 
 def generate_feedback(action: SQLAction, task: SQLTask, reward: SQLReward) -> str:
     """Human-readable feedback shown in the next observation."""
-    if reward.value >= 0.99:
+    if reward.value >= 0.98:
         return "Correct! Query matches perfectly."
     if reward.value >= 0.70:
         return "Very close — check spacing or minor clause differences."

sql_env/server.py

@@ -23,7 +23,7 @@ class SQLCorrectionEnvironment(Environment):
         self._current_task = None
         self._step_count = 0
         self._done = False
-        self._last_reward = 0.0
+        self._last_reward = 0.01
         self._rewards_history = []
         self._stagnation_count = 0
 
@@ -38,7 +38,7 @@ class SQLCorrectionEnvironment(Environment):
         self._current_task = random.choice(tasks)
         self._step_count = 0
         self._done = False
-        self._last_reward = 0.0
+        self._last_reward = 0.01
         self._rewards_history = []
         self._stagnation_count = 0
         return self._make_observation(previous_attempt=None, feedback=None)
@@ -58,15 +58,18 @@ class SQLCorrectionEnvironment(Environment):
                 reward = max(0.01, reward - 0.1)
         else:
             self._stagnation_count = 0
-
+        # Final Clamp  
+        reward = max(0.01, min(0.98, reward))
+          
         self._last_reward = reward
+
         self._rewards_history.append(reward)
 
-        done = (reward_obj.value >= 0.95) or (
+        done = (reward >= 0.95) or (
             self._step_count >= self._current_task.max_steps
         )
         self._done = done
-        feedback = generate_feedback(action, self._current_task, reward_obj)
+        feedback = generate_feedback(action, self._current_task, reward)
 
         return self._make_observation(
             previous_attempt=action.corrected_query,
@@ -82,7 +85,7 @@ class SQLCorrectionEnvironment(Environment):
                 step_count=0,
                 max_steps=0,
                 done=False,
-                last_reward=0.0,
+                last_reward=0.01,
                 rewards_history=[],
             )
         return SQLState(

tests/test_env.py

@@ -29,13 +29,13 @@ def _action(query: str) -> SQLAction:
 # ── Grader unit tests ─────────────────────────────────────────────────────────
 
 class TestGrader:
-    def test_exact_match_returns_one(self):
+    def test_exact_match_returns_099(self):
         task = _make_task(
             "SELECT * FORM users",
             "SELECT * FROM users",
         )
         reward = grade(_action("SELECT * FROM users"), task)
-        assert reward.value == 1.0
+        assert reward.value == 0.99
 
     def test_exact_match_case_insensitive(self):
         task = _make_task(
@@ -43,7 +43,7 @@ class TestGrader:
             "SELECT * FROM users",
         )
         reward = grade(_action("select * from users"), task)
-        assert reward.value == 1.0
+        assert reward.value == 0.99
 
     def test_exact_match_trailing_semicolon(self):
         task = _make_task(
@@ -51,23 +51,23 @@ class TestGrader:
             "SELECT * FROM users",
         )
         reward = grade(_action("SELECT * FROM users;"), task)
-        assert reward.value == 1.0
+        assert reward.value == 0.99
 
-    def test_wrong_answer_not_one(self):
+    def test_wrong_answer_not_perfect(self):
         task = _make_task(
             "SELECT * FORM users",
             "SELECT * FROM users",
         )
         reward = grade(_action("SELECT * FORM users"), task)
-        assert reward.value < 1.0
+        assert reward.value < 0.99
 
-    def test_completely_wrong_returns_zero(self):
+    def test_completely_wrong_returns_001(self):
         task = _make_task(
             "SELECT * FORM users",
             "SELECT * FROM users",
         )
         reward = grade(_action("hello world"), task)
-        assert reward.value == 0.0
+        assert reward.value == 0.01
 
     def test_basic_structure_returns_02(self):
         task = _make_task(
@@ -78,7 +78,7 @@ class TestGrader:
         reward = grade(_action("SELECT * FORM users WHERE id = 1"), task)
         assert reward.value == pytest.approx(0.2, abs=0.05)
 
-    def test_reward_range(self):
+    def test_reward_range_is_strictly_open(self):
         task = _make_task(
             "SELCT * FORM users WEHRE id = 1",
             "SELECT * FROM users WHERE id = 1",
@@ -90,8 +90,8 @@ class TestGrader:
             "select * from users where id = 1",
         ]:
             reward = grade(_action(query), task)
-            assert 0.0 <= reward.value <= 1.0, (
-                f"Reward {reward.value} out of [0, 1] for query: {query}"
+            assert 0.0 < reward.value < 1.0, (
+                f"Reward {reward.value} out of (0, 1) for query: {query}"
             )
 
     def test_feedback_not_empty(self):
@@ -142,24 +142,24 @@ class TestTaskCatalogue:
                 )
 
     def test_grading_canonical_answer_returns_perfect(self):
-        """Every task must return 1.0 when given its own canonical answer."""
+        """Every task must return 0.99 when given its own canonical answer."""
         for difficulty, tasks in ALL_TASKS.items():
             for task in tasks:
                 action = _action(task.canonical_answer)
                 reward = grade(action, task)
-                assert reward.value == 1.0, (
-                    f"{task.task_id}: canonical answer did not score 1.0 "
+                assert reward.value == 0.99, (
+                    f"{task.task_id}: canonical answer did not score 0.99 "
                     f"(got {reward.value})"
                 )
 
     def test_grading_broken_query_below_perfect(self):
-        """Broken queries must score below 1.0."""
+        """Broken queries must score below the perfect 0.99 score."""
         for difficulty, tasks in ALL_TASKS.items():
             for task in tasks:
                 action = _action(task.broken_query)
                 reward = grade(action, task)
-                assert reward.value < 1.0, (
-                    f"{task.task_id}: broken query unexpectedly scored 1.0"
+                assert reward.value < 0.99, (
+                    f"{task.task_id}: broken query unexpectedly scored 0.99"
                 )
 
 
@@ -182,7 +182,7 @@ class TestEnvironment:
             env = SQLCorrectionEnv(difficulty="easy")
             await env.reset()
             result = await env.step(_action("SELECT * FROM users WHERE id = 1"))
-            assert 0.0 <= result.reward <= 1.0
+            assert 0.0 < result.reward < 1.0
             assert isinstance(result.done, bool)
             assert result.observation.step_number == 1
 
@@ -204,7 +204,7 @@ class TestEnvironment:
             canonical = EASY_TASKS[0].canonical_answer
             result = await env.step(_action(canonical))
             assert result.done is True
-            assert result.reward == pytest.approx(1.0)
+            assert result.reward == pytest.approx(0.99)
 
         asyncio.run(run())