final grading logic fixes

graders/bug_fix.py

@@ -9,7 +9,16 @@ except ImportError:
     from models import TaskGrade
     from tasks.catalog import ReviewTask
 
-from .shared import base_grade, compile_code, execute_cases, quality_metrics, similarity_score, summarize_results
+from .shared import (
+    base_grade,
+    compile_code,
+    component_score,
+    execute_cases,
+    quality_metrics,
+    shaped_score,
+    similarity_score,
+    summarize_results,
+)
 
 
 def grade_bug_fix_task(
@@ -31,16 +40,16 @@ def grade_bug_fix_task(
     }
 
     if not compiled:
-        partial = round(min(0.2, similarity_score(code, task.reference_code) * 0.2), 3)
+        progress = 0.02 + 0.12 * similarity_score(code, task.reference_code)
         details["test_results"] = []
         details["test_summary"] = "Code does not compile."
         return base_grade(
-            score=partial,
-            syntax_score=0.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.01),
             tests_passed=0,
             tests_total=len(task.public_cases) + (len(task.hidden_cases) if include_hidden else 0),
-            quality_score=0.0,
-            runtime_score=0.0,
+            quality_score=component_score(0.01),
+            runtime_score=component_score(0.01),
             timed_out=False,
             details=details,
         )
@@ -50,26 +59,28 @@ def grade_bug_fix_task(
     if result.get("timed_out"):
         details["test_results"] = []
         details["test_summary"] = result["error"]
+        progress = 0.12 + 0.18 * quality["score"]
         return base_grade(
-            score=0.0,
-            syntax_score=1.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.95),
             tests_passed=0,
             tests_total=len(cases),
             quality_score=quality["score"],
-            runtime_score=0.0,
+            runtime_score=component_score(0.01),
             timed_out=True,
             details=details,
         )
     if "error" in result:
         details["test_results"] = []
         details["test_summary"] = result["error"]
+        progress = 0.1 + 0.2 * quality["score"]
         return base_grade(
-            score=0.0,
-            syntax_score=1.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.95),
             tests_passed=0,
             tests_total=len(cases),
             quality_score=quality["score"],
-            runtime_score=0.0,
+            runtime_score=component_score(0.01),
             timed_out=False,
             details=details,
         )
@@ -78,13 +89,14 @@ def grade_bug_fix_task(
     pass_rate = data["passed"] / max(data["total"], 1)
     details["test_results"] = data["results"]
     details["test_summary"] = summarize_results("Test results", data["results"])
+    progress = min(1.0, 0.05 + 0.8 * pass_rate + 0.15 * quality["score"])
     return base_grade(
-        score=pass_rate,
-        syntax_score=1.0,
+        score=shaped_score(progress),
+        syntax_score=component_score(0.95),
         tests_passed=data["passed"],
         tests_total=data["total"],
         quality_score=quality["score"],
-        runtime_score=0.0,
+        runtime_score=component_score(0.01),
         timed_out=False,
         details=details,
     )

graders/optimization.py

@@ -13,8 +13,10 @@ from .shared import (
     base_grade,
     benchmark_candidate,
     compile_code,
+    component_score,
     execute_cases,
     quality_metrics,
+    shaped_score,
     similarity_score,
     summarize_results,
 )
@@ -39,16 +41,16 @@ def grade_optimization_task(
     }
 
     if not compiled:
-        partial = round(min(0.15, similarity_score(code, task.reference_code) * 0.15), 3)
+        progress = 0.02 + 0.1 * similarity_score(code, task.reference_code)
         details["test_results"] = []
         details["test_summary"] = "Code does not compile."
         return base_grade(
-            score=partial,
-            syntax_score=0.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.01),
             tests_passed=0,
             tests_total=len(task.public_cases) + (len(task.hidden_cases) if include_hidden else 0),
-            quality_score=0.0,
-            runtime_score=0.0,
+            quality_score=component_score(0.01),
+            runtime_score=component_score(0.01),
             timed_out=False,
             details=details,
         )
@@ -58,33 +60,35 @@ def grade_optimization_task(
     if result.get("timed_out"):
         details["test_results"] = []
         details["test_summary"] = result["error"]
+        progress = 0.1 + 0.18 * quality["score"]
         return base_grade(
-            score=0.0,
-            syntax_score=1.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.95),
             tests_passed=0,
             tests_total=len(cases),
             quality_score=quality["score"],
-            runtime_score=0.0,
+            runtime_score=component_score(0.01),
             timed_out=True,
             details=details,
         )
     if "error" in result:
         details["test_results"] = []
         details["test_summary"] = result["error"]
+        progress = 0.1 + 0.2 * quality["score"]
         return base_grade(
-            score=0.0,
-            syntax_score=1.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.95),
             tests_passed=0,
             tests_total=len(cases),
             quality_score=quality["score"],
-            runtime_score=0.0,
+            runtime_score=component_score(0.01),
             timed_out=False,
             details=details,
         )
 
     data = result["data"]
     pass_rate = data["passed"] / max(data["total"], 1)
-    runtime_score = 0.0
+    runtime_score = component_score(0.01)
     benchmark_summary = "Benchmark deferred until hidden evaluation."
     timed_out = False
 
@@ -94,20 +98,21 @@ def grade_optimization_task(
         timed_out = benchmark.get("timed_out", False)
         benchmark_summary = benchmark["details"]
         if timed_out:
-            runtime_score = 0.0
+            runtime_score = component_score(0.01)
 
     details["test_results"] = data["results"]
     details["test_summary"] = summarize_results("Test results", data["results"])
     details["benchmark"] = benchmark_summary
 
+    runtime_progress = 0.0 if benchmark_summary == "Benchmark deferred until hidden evaluation." else runtime_score
     if include_hidden:
-        score = 0.5 * pass_rate + 0.3 * runtime_score + 0.2 * quality["score"]
+        progress = min(1.0, 0.05 + 0.6 * pass_rate + 0.2 * quality["score"] + 0.15 * runtime_progress)
     else:
-        score = 0.7 * pass_rate + 0.3 * quality["score"]
+        progress = min(1.0, 0.05 + 0.7 * pass_rate + 0.25 * quality["score"])
 
     return base_grade(
-        score=score,
-        syntax_score=1.0,
+        score=shaped_score(progress),
+        syntax_score=component_score(0.95),
         tests_passed=data["passed"],
         tests_total=data["total"],
         quality_score=quality["score"],

graders/shared.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import ast
 import difflib
+import math
 import multiprocessing as mp
 import time
 import traceback
@@ -17,10 +18,71 @@ except ImportError:
     from tasks.catalog import CallCase, ReviewTask
 
 
+STRICT_SCORE_MIN = 0.01
+STRICT_SCORE_MAX = 0.99
+POOR_SCORE = 0.1
+NEAR_PERFECT_SCORE = 0.95
+
+
+def finite_float(value: Any, fallback: float = STRICT_SCORE_MIN) -> float:
+    """Convert a value into a finite float with a deterministic fallback."""
+
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        return fallback
+    if math.isnan(numeric) or math.isinf(numeric):
+        return fallback
+    return numeric
+
+
 def clamp(value: float, lower: float = 0.0, upper: float = 1.0) -> float:
     """Clamp a floating-point value to a closed interval."""
 
-    return max(lower, min(upper, value))
+    numeric = finite_float(value, fallback=lower)
+    return max(lower, min(upper, numeric))
+
+
+def strict_score(value: Any, lower: float = STRICT_SCORE_MIN, upper: float = STRICT_SCORE_MAX) -> float:
+    """Clamp a score to the OpenEnv-safe open interval (0, 1)."""
+
+    score = max(lower, min(upper, finite_float(value, fallback=lower)))
+    score = round(score, 3)
+    assert 0 < score < 1, f"Invalid score: {score}"
+    return score
+
+
+def shaped_score(progress: Any, floor: float = POOR_SCORE, ceiling: float = NEAR_PERFECT_SCORE) -> float:
+    """Map progress in [0, 1] to a shaped score band within (0, 1)."""
+
+    bounded_progress = clamp(finite_float(progress, fallback=0.0))
+    score = floor + (ceiling - floor) * bounded_progress
+    score = max(STRICT_SCORE_MIN, min(score, STRICT_SCORE_MAX))
+    score = round(score, 3)
+    assert 0 < score < 1, f"Invalid score: {score}"
+    return score
+
+
+def score_from_checks(passed: int, total: int, floor: float = POOR_SCORE, ceiling: float = NEAR_PERFECT_SCORE) -> float:
+    """Convert discrete checks into a smoothly shaped score."""
+
+    return shaped_score(safe_ratio(passed, total), floor=floor, ceiling=ceiling)
+
+
+def safe_ratio(numerator: Any, denominator: Any) -> float:
+    """Return a stable ratio in [0, 1] that never raises or produces NaN."""
+
+    denom = int(finite_float(denominator, fallback=0.0))
+    if denom <= 0:
+        return 0.0
+    numer = finite_float(numerator, fallback=0.0)
+    return clamp(numer / denom)
+
+
+def component_score(value: Any) -> float:
+    """Normalize component scores such as syntax, quality, and runtime."""
+
+    return strict_score(value)
 
 
 def compile_code(code: str) -> tuple[bool, str]:
@@ -157,8 +219,8 @@ def quality_metrics(code: str, function_name: str) -> Dict[str, Any]:
     compiled, error = compile_code(code)
     if not compiled:
         return {
-            "score": 0.0,
-            "style_score": 0.0,
+            "score": component_score(STRICT_SCORE_MIN),
+            "style_score": component_score(STRICT_SCORE_MIN),
             "quality_notes": [error],
             "max_loop_depth": 99,
         }
@@ -238,8 +300,8 @@ def quality_metrics(code: str, function_name: str) -> Dict[str, Any]:
         score += 0.15
 
     return {
-        "score": round(clamp(score), 3),
-        "style_score": round(clamp(style_score), 3),
+        "score": component_score(clamp(score)),
+        "style_score": component_score(clamp(style_score)),
         "quality_notes": notes,
         "max_loop_depth": max_loop_depth,
     }
@@ -294,7 +356,7 @@ def benchmark_candidate(task: ReviewTask, code: str, timeout_s: float) -> Dict[s
     """Benchmark a candidate solution against the starter implementation."""
 
     if not task.benchmark_config:
-        return {"runtime_score": 0.0, "details": "No benchmark configured."}
+        return {"runtime_score": component_score(STRICT_SCORE_MIN), "details": "No benchmark configured."}
 
     events = build_benchmark_events(task.benchmark_config)
     payload = {
@@ -306,15 +368,15 @@ def benchmark_candidate(task: ReviewTask, code: str, timeout_s: float) -> Dict[s
     }
     result = run_with_timeout(_benchmark_worker, payload, timeout_s=timeout_s)
     if result.get("timed_out"):
-        return {"runtime_score": 0.0, "timed_out": True, "details": result["error"]}
+        return {"runtime_score": component_score(STRICT_SCORE_MIN), "timed_out": True, "details": result["error"]}
     if "error" in result:
-        return {"runtime_score": 0.0, "timed_out": False, "details": result["error"]}
+        return {"runtime_score": component_score(STRICT_SCORE_MIN), "timed_out": False, "details": result["error"]}
 
     data = result["data"]
     baseline_seconds = float(data["baseline_seconds"])
     candidate_seconds = float(data["candidate_seconds"])
     improvement_ratio = baseline_seconds / max(candidate_seconds, 1e-9)
-    runtime_score = round(clamp((improvement_ratio - 1.0) / 1.5), 3)
+    runtime_score = component_score(clamp((improvement_ratio - 1.0) / 1.5))
     return {
         "runtime_score": runtime_score,
         "timed_out": False,
@@ -352,13 +414,18 @@ def base_grade(
 ) -> TaskGrade:
     """Create a normalized TaskGrade payload."""
 
+    safe_score = strict_score(score)
+    safe_syntax_score = component_score(syntax_score)
+    safe_quality_score = component_score(quality_score)
+    safe_runtime_score = component_score(runtime_score)
+
     return TaskGrade(
-        score=round(clamp(score), 3),
-        syntax_score=round(clamp(syntax_score), 3),
+        score=safe_score,
+        syntax_score=safe_syntax_score,
         tests_passed=tests_passed,
         tests_total=tests_total,
-        quality_score=round(clamp(quality_score), 3),
-        runtime_score=round(clamp(runtime_score), 3),
+        quality_score=safe_quality_score,
+        runtime_score=safe_runtime_score,
         timed_out=timed_out,
         details=details,
     )

graders/syntax.py

@@ -9,7 +9,16 @@ except ImportError:
     from models import TaskGrade
     from tasks.catalog import ReviewTask
 
-from .shared import base_grade, compile_code, execute_cases, quality_metrics, similarity_score, summarize_results
+from .shared import (
+    base_grade,
+    compile_code,
+    component_score,
+    execute_cases,
+    quality_metrics,
+    shaped_score,
+    similarity_score,
+    summarize_results,
+)
 
 
 def grade_syntax_task(task: ReviewTask, code: str, timeout_s: float = 2.0) -> TaskGrade:
@@ -24,16 +33,16 @@ def grade_syntax_task(task: ReviewTask, code: str, timeout_s: float = 2.0) -> Ta
     }
 
     if not compiled:
-        partial = round(min(0.7, similarity_score(code, task.reference_code) * 0.7), 3)
+        progress = 0.05 + 0.2 * similarity_score(code, task.reference_code)
         details["test_results"] = []
         details["test_summary"] = "Code does not compile yet."
         return base_grade(
-            score=partial,
-            syntax_score=0.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.01),
             tests_passed=0,
             tests_total=len(task.public_cases) + len(task.hidden_cases),
-            quality_score=0.0,
-            runtime_score=0.0,
+            quality_score=component_score(0.01),
+            runtime_score=component_score(0.01),
             timed_out=False,
             details=details,
         )
@@ -43,26 +52,28 @@ def grade_syntax_task(task: ReviewTask, code: str, timeout_s: float = 2.0) -> Ta
     if result.get("timed_out"):
         details["test_results"] = []
         details["test_summary"] = result["error"]
+        progress = 0.2 + 0.25 * quality["score"]
         return base_grade(
-            score=0.8,
-            syntax_score=1.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.95),
             tests_passed=0,
             tests_total=len(cases),
             quality_score=quality["score"],
-            runtime_score=0.0,
+            runtime_score=component_score(0.01),
             timed_out=True,
             details=details,
         )
     if "error" in result:
         details["test_results"] = []
         details["test_summary"] = result["error"]
+        progress = 0.18 + 0.2 * quality["score"]
         return base_grade(
-            score=1.0,
-            syntax_score=1.0,
+            score=shaped_score(progress),
+            syntax_score=component_score(0.95),
             tests_passed=0,
             tests_total=len(cases),
             quality_score=quality["score"],
-            runtime_score=0.0,
+            runtime_score=component_score(0.01),
             timed_out=False,
             details=details,
         )
@@ -70,13 +81,15 @@ def grade_syntax_task(task: ReviewTask, code: str, timeout_s: float = 2.0) -> Ta
     data = result["data"]
     details["test_results"] = data["results"]
     details["test_summary"] = summarize_results("Validation checks", data["results"])
+    pass_rate = data["passed"] / max(data["total"], 1)
+    progress = min(1.0, 0.15 + 0.75 * pass_rate + 0.1 * quality["score"])
     return base_grade(
-        score=1.0,
-        syntax_score=1.0,
+        score=shaped_score(progress),
+        syntax_score=component_score(0.95),
         tests_passed=data["passed"],
         tests_total=data["total"],
         quality_score=quality["score"],
-        runtime_score=0.0,
+        runtime_score=component_score(0.01),
         timed_out=False,
         details=details,
     )

inference.py

@@ -49,6 +49,9 @@ DEFAULT_MODEL_NAME = "mock-model"
 API_TIMEOUT_SECONDS = 3.0
 API_RETRIES = 1
 API_RETRY_DELAY_SECONDS = 0.2
+MIN_SCORE = 0.01
+POOR_SCORE = 0.1
+MAX_SCORE = 0.99
 
 
 def safe_env(name: str, default: str = "") -> str:
@@ -61,14 +64,19 @@ def safe_env(name: str, default: str = "") -> str:
 
 
 def clamp_score(value: Any) -> float:
-    """Clamp numeric scores to the required 0..1 interval."""
+    """Clamp numeric scores to the required open interval (0, 1)."""
     try:
-        return max(0.0, min(1.0, float(value)))
+        numeric = float(value)
     except Exception:
-        return 0.0
+        return MIN_SCORE
+    if numeric != numeric or numeric in (float("inf"), float("-inf")):
+        return MIN_SCORE
+    numeric = max(MIN_SCORE, min(MAX_SCORE, numeric))
+    assert 0 < numeric < 1, f"Invalid score: {numeric}"
+    return numeric
 
 
-def safe_float(value: Any, default: float = 0.0) -> float:
+def safe_float(value: Any, default: float = POOR_SCORE) -> float:
     """Convert a value to float without raising."""
     try:
         return float(value)
@@ -163,7 +171,7 @@ def build_prompt(observation: Any) -> str:
         task_description = safe_text(safe_getattr(observation, "task_description", ""), "No task description.")
         errors = safe_text(safe_getattr(observation, "errors", ""), "none")
         tests = safe_text(safe_getattr(observation, "test_results", ""), "not available")
-        score = clamp_score(safe_getattr(observation, "score", 0.0))
+        score = clamp_score(safe_getattr(observation, "score", POOR_SCORE))
         current_code = safe_code(safe_getattr(observation, "current_code", ""), "")
         visible_tests = safe_getattr(observation, "visible_tests", [])
         if not isinstance(visible_tests, Iterable) or isinstance(visible_tests, (str, bytes)):
@@ -262,10 +270,10 @@ def observation_reward(observation: Any) -> float:
     """Extract the scalar step reward from an observation."""
     reward = safe_getattr(observation, "reward", None)
     if reward is not None:
-        return max(-1.0, min(1.0, safe_float(reward, 0.0)))
+        return clamp_score(safe_float(reward, POOR_SCORE))
     reward_details = safe_getattr(observation, "reward_details", None)
-    reward_value = safe_getattr(reward_details, "value", 0.0)
-    return max(-1.0, min(1.0, safe_float(reward_value, 0.0)))
+    reward_value = safe_getattr(reward_details, "value", POOR_SCORE)
+    return clamp_score(safe_float(reward_value, POOR_SCORE))
 
 
 def fallback_first_action(task_id: str) -> dict[str, Any]:
@@ -306,22 +314,22 @@ def run_task(task_id: str, client: Any | None, model: str) -> None:
     emit_start(task_id)
 
     if PythonCodeReviewEnvironment is None:
-        emit_step(1, 0.0)
-        emit_end(task_id, 0.0, 1)
+        emit_step(1, POOR_SCORE)
+        emit_end(task_id, POOR_SCORE, 1)
         return
 
     try:
         with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
             env = PythonCodeReviewEnvironment(verbose=False)
     except Exception:
-        emit_step(1, 0.0)
-        emit_end(task_id, 0.0, 1)
+        emit_step(1, POOR_SCORE)
+        emit_end(task_id, POOR_SCORE, 1)
         return
 
     observation = safe_reset(env, task_id)
     if observation is None:
-        emit_step(1, 0.0)
-        emit_end(task_id, 0.0, 1)
+        emit_step(1, POOR_SCORE)
+        emit_end(task_id, POOR_SCORE, 1)
         return
 
     step_count = 0
@@ -347,14 +355,14 @@ def run_task(task_id: str, client: Any | None, model: str) -> None:
         next_observation = safe_step(env, make_action(action_payload))
         step_count += 1
         if next_observation is None:
-            emit_step(step_count, 0.0)
-            emit_end(task_id, clamp_score(safe_getattr(final_observation, "score", 0.0)), step_count)
+            emit_step(step_count, POOR_SCORE)
+            emit_end(task_id, clamp_score(safe_getattr(final_observation, "score", POOR_SCORE)), step_count)
             return
 
         final_observation = next_observation
         emit_step(step_count, observation_reward(final_observation))
 
-    emit_end(task_id, clamp_score(safe_getattr(final_observation, "score", 0.0)), step_count)
+    emit_end(task_id, clamp_score(safe_getattr(final_observation, "score", POOR_SCORE)), step_count)
 
 
 def main() -> int:
@@ -366,8 +374,8 @@ def main() -> int:
             run_task(task_id, client, model_name)
         except Exception:
             emit_start(task_id)
-            emit_step(1, 0.0)
-            emit_end(task_id, 0.0, 1)
+            emit_step(1, POOR_SCORE)
+            emit_end(task_id, POOR_SCORE, 1)
     return 0
 
 

models.py

@@ -20,13 +20,13 @@ class HistoryEntry(BaseModel):
     step: int = Field(..., ge=0)
     action_type: ActionType
     status: str = Field(..., description="Short outcome summary.")
-    reward: float = Field(..., description="Reward returned for the step.")
+    reward: float = Field(..., gt=0.0, lt=1.0, description="Reward returned for the step.")
 
 
 class RewardDetails(BaseModel):
     """Transparent reward decomposition for debugging and training."""
 
-    value: float = Field(..., description="Clamped net reward in [-1.0, 1.0].")
+    value: float = Field(..., gt=0.0, lt=1.0, description="Clamped net reward in (0.0, 1.0).")
     syntax_reward: float = Field(default=0.0)
     test_reward: float = Field(default=0.0)
     correctness_bonus: float = Field(default=0.0)
@@ -37,8 +37,8 @@ class RewardDetails(BaseModel):
     regression_penalty: float = Field(default=0.0)
     stagnation_penalty: float = Field(default=0.0)
     reason: str = Field(..., description="Human-readable reward explanation.")
-    prev_score: float = Field(default=0.0, ge=0.0, le=1.0)
-    curr_score: float = Field(default=0.0, ge=0.0, le=1.0)
+    prev_score: float = Field(default=0.01, gt=0.0, lt=1.0)
+    curr_score: float = Field(default=0.01, gt=0.0, lt=1.0)
     code_changed: bool = Field(default=False)
 
 
@@ -67,9 +67,9 @@ class PythonCodeReviewObservation(Observation):
     history: List[HistoryEntry] = Field(default_factory=list)
     attempts_remaining: int = Field(..., ge=0)
     last_action_status: str = Field(default="")
-    score: float = Field(..., ge=0.0, le=1.0)
+    score: float = Field(..., gt=0.0, lt=1.0)
     reward_details: RewardDetails = Field(
-        default_factory=lambda: RewardDetails(value=0.0, reason="Environment reset.")
+        default_factory=lambda: RewardDetails(value=0.1, reason="Environment reset.")
     )
 
 
@@ -84,7 +84,7 @@ class PythonCodeReviewState(State):
     errors: str = Field(default="")
     test_results: str = Field(default="")
     history: List[HistoryEntry] = Field(default_factory=list)
-    score: float = Field(default=0.0, ge=0.0, le=1.0)
+    score: float = Field(default=0.01, gt=0.0, lt=1.0)
     done: bool = Field(default=False)
 
 
@@ -117,12 +117,12 @@ class TaskSummary(BaseModel):
 class TaskGrade(BaseModel):
     """Deterministic grader output."""
 
-    score: float = Field(..., ge=0.0, le=1.0)
-    syntax_score: float = Field(default=0.0, ge=0.0, le=1.0)
+    score: float = Field(..., gt=0.0, lt=1.0)
+    syntax_score: float = Field(default=0.01, gt=0.0, lt=1.0)
     tests_passed: int = Field(default=0, ge=0)
     tests_total: int = Field(default=0, ge=0)
-    quality_score: float = Field(default=0.0, ge=0.0, le=1.0)
-    runtime_score: float = Field(default=0.0, ge=0.0, le=1.0)
+    quality_score: float = Field(default=0.01, gt=0.0, lt=1.0)
+    runtime_score: float = Field(default=0.01, gt=0.0, lt=1.0)
     timed_out: bool = Field(default=False)
     details: Dict[str, Any] = Field(default_factory=dict)
 

server/env.py

@@ -10,6 +10,7 @@ from openenv.core.env_server.types import EnvironmentMetadata
 
 try:
     from ..graders import grade_task
+    from ..graders.shared import component_score, safe_ratio, strict_score
     from ..models import (
         HistoryEntry,
         PythonCodeReviewAction,
@@ -21,6 +22,7 @@ try:
     from ..tasks import ReviewTask, list_tasks, select_task
 except ImportError:
     from graders import grade_task
+    from graders.shared import component_score, safe_ratio, strict_score
     from models import (
         HistoryEntry,
         PythonCodeReviewAction,
@@ -33,11 +35,18 @@ except ImportError:
 
 
 def _empty_grade() -> TaskGrade:
-    return TaskGrade(score=0.0, syntax_score=0.0, tests_passed=0, tests_total=0, quality_score=0.0, runtime_score=0.0)
+    return TaskGrade(
+        score=component_score(0.01),
+        syntax_score=component_score(0.01),
+        tests_passed=0,
+        tests_total=0,
+        quality_score=component_score(0.01),
+        runtime_score=component_score(0.01),
+    )
 
 
-def _clamp(value: float, lower: float = -1.0, upper: float = 1.0) -> float:
-    return max(lower, min(upper, value))
+def _reward_value(value: float) -> float:
+    return strict_score(value)
 
 
 class PythonCodeReviewEnvironment(
@@ -53,7 +62,7 @@ class PythonCodeReviewEnvironment(
         self._task: ReviewTask = list_tasks()[0]
         self._current_code: str = self._task.starter_code
         self._history: list[HistoryEntry] = []
-        self._last_reward = RewardDetails(value=0.0, reason="Environment initialized.")
+        self._last_reward = RewardDetails(value=0.1, reason="Environment initialized.")
         self._current_grade = _empty_grade()
         self._state = PythonCodeReviewState(episode_id=str(uuid4()), step_count=0)
         self.reset()
@@ -68,7 +77,7 @@ class PythonCodeReviewEnvironment(
         self._task = select_task(seed=seed, task_id=task_id)
         self._current_code = self._task.starter_code
         self._history = []
-        self._last_reward = RewardDetails(value=0.0, reason="Environment reset.")
+        self._last_reward = RewardDetails(value=0.1, reason="Environment reset.")
         self._current_grade = grade_task(self._task, self._current_code, include_hidden=False)
 
         self._state = PythonCodeReviewState(
@@ -117,7 +126,10 @@ class PythonCodeReviewEnvironment(
         **kwargs: Any,
     ) -> Tuple[PythonCodeReviewObservation, float, bool, Dict[str, Any]]:
         if self._state.done:
-            reward = RewardDetails(value=0.0, reason="Episode already finished. Call reset() to continue.")
+            reward = RewardDetails(
+                value=_reward_value(0.05 + 0.25 * self._current_grade.score),
+                reason="Episode already finished. Call reset() to continue.",
+            )
             observation = self._build_observation(
                 grade=self._current_grade,
                 status="Episode already finished.",
@@ -266,22 +278,24 @@ class PythonCodeReviewEnvironment(
     ) -> RewardDetails:
         prev_score = previous_grade.score
         curr_score = current_grade.score
-        prev_rate = previous_grade.tests_passed / max(previous_grade.tests_total, 1)
-        curr_rate = current_grade.tests_passed / max(current_grade.tests_total, 1)
+        prev_rate = safe_ratio(previous_grade.tests_passed, previous_grade.tests_total)
+        curr_rate = safe_ratio(current_grade.tests_passed, current_grade.tests_total)
 
-        syntax_reward = 0.2 if previous_grade.syntax_score < 1.0 and current_grade.syntax_score >= 1.0 else 0.0
-        test_reward = round(max(curr_rate - prev_rate, 0.0) * 0.3, 3)
-        progress_delta = round(max(curr_score - prev_score, 0.0) * 0.4, 3)
-        quality_bonus = round(max(current_grade.quality_score - previous_grade.quality_score, 0.0) * 0.1, 3)
-        correctness_bonus = 0.5 if final_submission and curr_score >= 0.999 and prev_score < 0.999 else 0.0
+        syntax_reward = 0.14 if previous_grade.syntax_score < 0.9 and current_grade.syntax_score >= 0.9 else 0.0
+        test_reward = round(max(curr_rate - prev_rate, 0.0) * 0.22, 3)
+        progress_delta = round(max(curr_score - prev_score, 0.0) * 0.35, 3)
+        quality_bonus = round(max(current_grade.quality_score - previous_grade.quality_score, 0.0) * 0.08, 3)
+        correctness_bonus = 0.12 if final_submission and curr_score >= 0.94 and prev_score < 0.94 else 0.0
 
-        invalid_action_penalty = 0.1 if invalid_action else 0.0
-        timeout_penalty = 0.2 if timed_out else 0.0
+        invalid_action_penalty = 0.12 if invalid_action else 0.0
+        timeout_penalty = 0.14 if timed_out else 0.0
         regression_penalty = round(max(prev_score - curr_score, 0.0) * 0.2, 3)
-        stagnation_penalty = 0.05 if action.action_type == "edit_code" and not code_changed else 0.0
+        stagnation_penalty = 0.06 if action.action_type == "edit_code" and not code_changed else 0.0
 
-        value = _clamp(
-            syntax_reward
+        raw_value = (
+            0.1
+            + 0.45 * curr_score
+            + syntax_reward
             + test_reward
             + progress_delta
             + quality_bonus
@@ -291,6 +305,7 @@ class PythonCodeReviewEnvironment(
             - regression_penalty
             - stagnation_penalty
         )
+        value = _reward_value(raw_value)
 
         reason_parts = []
         if syntax_reward:
@@ -315,7 +330,7 @@ class PythonCodeReviewEnvironment(
             reason_parts.append("no meaningful state change")
 
         return RewardDetails(
-            value=round(value, 3),
+            value=value,
             syntax_reward=syntax_reward,
             test_reward=test_reward,
             correctness_bonus=correctness_bonus,
@@ -365,7 +380,7 @@ class PythonCodeReviewEnvironment(
 
     def _submission_status(self, grade: TaskGrade) -> str:
         runtime_text = ""
-        if grade.runtime_score:
+        if isinstance(grade.details.get("benchmark"), dict):
             runtime_text = f" runtime {grade.runtime_score:.2f};"
         return (
             f"Submission graded with score {grade.score:.2f}; "

tests/test_scoring.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from graders import grade_task
+from models import PythonCodeReviewAction
+from server.env import PythonCodeReviewEnvironment
+from tasks import list_tasks
+
+
+def assert_open_unit_interval(value: float) -> None:
+    assert 0 < value < 1, f"Invalid score: {value}"
+
+
+def test_task_grades_stay_strictly_between_zero_and_one() -> None:
+    for task in list_tasks():
+        starter_grade = grade_task(task, task.starter_code, include_hidden=False)
+        reference_grade = grade_task(task, task.reference_code, include_hidden=True)
+
+        for grade in (starter_grade, reference_grade):
+            assert_open_unit_interval(grade.score)
+            assert_open_unit_interval(grade.syntax_score)
+            assert_open_unit_interval(grade.quality_score)
+            assert_open_unit_interval(grade.runtime_score)
+
+
+def test_environment_scores_and_rewards_stay_in_open_interval() -> None:
+    env = PythonCodeReviewEnvironment(verbose=False)
+    observation = env.reset(task_id="bug_fix_session_windows")
+
+    assert_open_unit_interval(observation.score)
+    assert_open_unit_interval(observation.reward_details.value)
+
+    no_op_action = PythonCodeReviewAction(action_type="edit_code", code=observation.current_code)
+    next_observation, reward, _, _ = env.step_result(no_op_action)
+    assert_open_unit_interval(next_observation.score)
+    assert_open_unit_interval(reward)
+    assert_open_unit_interval(next_observation.reward_details.value)
+
+    submit_action = PythonCodeReviewAction(action_type="submit_solution", code=env._task.reference_code)
+    final_observation, final_reward, _, _ = env.step_result(submit_action)
+    assert_open_unit_interval(final_observation.score)
+    assert_open_unit_interval(final_reward)
+    assert_open_unit_interval(final_observation.reward_details.value)