Upload folder using huggingface_hub

inference.py

@@ -27,12 +27,18 @@ ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://localhost:8000")
 BENCHMARK = os.getenv("BENCHMARK", "coding_env")
 MAX_STEPS = int(os.getenv("MAX_STEPS", "1"))
 SUCCESS_SCORE_THRESHOLD = float(os.getenv("SUCCESS_SCORE_THRESHOLD", "0.60"))
+MIN_STRICT_SCORE = 0.01
+MAX_STRICT_SCORE = 0.99
 
 
 def _bool_text(value: bool) -> str:
     return "true" if value else "false"
 
 
+def _strict_score(value: float) -> float:
+    return max(MIN_STRICT_SCORE, min(MAX_STRICT_SCORE, round(float(value), 4)))
+
+
 def log_start(task: str, env: str, model: str) -> None:
     print(f"[START] task={task} env={env} model={model}", flush=True)
 
@@ -129,7 +135,7 @@ line_number (integer), confidence (0.0-1.0 float)
 def run_task(task_id: str, client: OpenAI | None) -> float:
     episode_id = f"baseline-{task_id}"
     rewards: List[float] = []
-    score = 0.0
+    score = MIN_STRICT_SCORE
     success = False
     last_error: str | None = None
     steps_taken = 0
@@ -163,7 +169,7 @@ def run_task(task_id: str, client: OpenAI | None) -> float:
                     "episode_id": episode_id,
                 },
             )
-            reward = float(step_data.get("reward", 0.0) or 0.0)
+            reward = _strict_score(float(step_data.get("reward", MIN_STRICT_SCORE) or MIN_STRICT_SCORE))
             done = bool(step_data.get("done", not bool(step_data)))
             obs_after = step_data.get("observation", {}) if isinstance(step_data, dict) else {}
             raw_error = obs_after.get("last_action_error")
@@ -179,17 +185,23 @@ def run_task(task_id: str, client: OpenAI | None) -> float:
         grader_data = _safe_json(
             "GET", f"{ENV_BASE_URL}/grader?task_id={task_id}&episode_id={episode_id}"
         )
-        grader_score = float(grader_data.get("score", 0.0) or 0.0)
-        step_score = rewards[-1] if rewards else 0.0
-        score = max(grader_score, step_score)
+        grader_score = _strict_score(float(grader_data.get("score", MIN_STRICT_SCORE) or MIN_STRICT_SCORE))
+        step_score = _strict_score(rewards[-1] if rewards else MIN_STRICT_SCORE)
+        score = _strict_score(max(grader_score, step_score))
         success = score >= SUCCESS_SCORE_THRESHOLD
     except Exception as exc:
         last_error = str(exc)
         if steps_taken == 0:
-            log_step(1, "bug_type=none;line=-1;confidence=0.00", 0.0, True, last_error)
-            rewards.append(0.0)
+            log_step(
+                1,
+                "bug_type=none;line=-1;confidence=0.00",
+                MIN_STRICT_SCORE,
+                True,
+                last_error,
+            )
+            rewards.append(MIN_STRICT_SCORE)
             steps_taken = 1
-        score = 0.0
+        score = MIN_STRICT_SCORE
         success = False
     finally:
         log_end(success, max(1, steps_taken), score, rewards or [0.0])

server/task_bank.py

@@ -88,6 +88,8 @@ TASKS: Dict[str, CodeReviewTask] = {
 
 EPISODE_SCORES: Dict[tuple[str, str], float] = {}
 SCORE_FILE = os.getenv("CODING_ENV_SCORE_FILE", "/tmp/coding_env_episode_scores.json")
+MIN_STRICT_SCORE = 0.01
+MAX_STRICT_SCORE = 0.99
 
 
 def list_tasks() -> List[Dict[str, str]]:
@@ -146,13 +148,13 @@ def grade_action(action: CodeAction, task: CodeReviewTask) -> tuple[float, str]:
     else:
         parts.append("review lacks key evidence (+0.00)")
 
-    score = max(0.0, min(1.0, round(score, 4)))
+    score = _to_strict_open_score(score)
     return score, "; ".join(parts)
 
 
 def record_episode_score(task_id: str, episode_id: str, score: float) -> None:
     """Persist normalized score for grader endpoint."""
-    normalized = max(0.0, min(1.0, float(score)))
+    normalized = _to_strict_open_score(score)
     EPISODE_SCORES[(task_id, episode_id)] = normalized
     _persist_score(task_id, episode_id, normalized)
 
@@ -194,6 +196,11 @@ def _load_persisted_score(task_id: str, episode_id: str) -> float:
             loaded = json.load(f)
         key = f"{task_id}::{episode_id}"
         value = loaded.get(key, 0.0) if isinstance(loaded, dict) else 0.0
-        return max(0.0, min(1.0, float(value)))
+        return _to_strict_open_score(value)
     except Exception:
-        return 0.0
+        return MIN_STRICT_SCORE
+
+
+def _to_strict_open_score(value: float) -> float:
+    """Clamp to strict open interval (0, 1) as required by validator."""
+    return max(MIN_STRICT_SCORE, min(MAX_STRICT_SCORE, round(float(value), 4)))