final 2 6

app/environment.py

@@ -66,7 +66,7 @@ class EnvironmentManager:
         self._sessions: Dict[str, Session] = {}
 
     @staticmethod
-    def _clamp_score_strict(score: float, eps: float = 1e-3) -> float:
+    def _clamp_score_strict(score: float, eps: float = 0.01) -> float:
         """
         Hackathon validator requirement: task scores must be strictly within (0, 1).
         We clamp away from exact endpoints to avoid returning 0.0 or 1.0.

app/main.py

@@ -226,13 +226,19 @@ async def baseline(request: BaselineRequest = Body(default=BaselineRequest())):
             max_steps=request.max_steps,
             task_ids=request.tasks,
         )
+
+        # Ensure validator-safe scores even if baseline errored or returned edge values.
+        safe_scores = [env_manager._clamp_score_strict(r.get("score", 0.0)) for r in results]
+        for r, s in zip(results, safe_scores):
+            r["score"] = s
+
         return {
             "model": request.model,
             "results": results,
             "summary": {
                 "mean_score": round(
-                    sum(r["score"] for r in results) / len(results), 4
-                ) if results else 0.0,
+                    sum(safe_scores) / len(safe_scores), 4
+                ) if safe_scores else env_manager._clamp_score_strict(0.0),
                 "tasks_passed": sum(
                     1 for r in results
                     if r["score"] >= TASK_REGISTRY[r["task_id"]].passing_score

app/tasks/base.py

@@ -122,7 +122,7 @@ class BaseTask(ABC):
         ...
 
     @staticmethod
-    def clamp_score_strict(score: float, eps: float = 1e-3) -> float:
+    def clamp_score_strict(score: float, eps: float = 0.01) -> float:
         """
         Hackathon validator requirement: scores must be strictly within (0, 1).
         Use this at the end of task graders to avoid returning exactly 0.0 or 1.0.

baseline.py

@@ -80,6 +80,22 @@ Respond ONLY with JSON. No markdown. No explanation."""
 
 # ─── Helpers ─────────────────────────────────────────────────────────────────
 
+def clamp_score_strict(score: float, eps: float = 1e-3) -> float:
+    """
+    Hackathon validator requirement: scores must be strictly within (0, 1).
+    Clamp away from endpoints to avoid returning exactly 0.0 or 1.0.
+    """
+    try:
+        s = float(score)
+    except Exception:
+        s = 0.0
+    if s <= 0.0:
+        return eps
+    if s >= 1.0:
+        return 1.0 - eps
+    return s
+
+
 def log(msg: str, level: str = "INFO"):
     prefix = {"INFO": "ℹ", "OK": "✓", "WARN": "⚠", "ERR": "✗"}.get(level, "•")
     print(f"  {prefix} {msg}")
@@ -283,13 +299,14 @@ def run_task(
                 task_info = t
                 break
 
+    final_score = clamp_score_strict(score)
     return {
         "task_id": task_id,
         "task_name": task_info.get("name", task_id),
         "difficulty": task_info.get("difficulty", "?"),
-        "score": score,
+        "score": final_score,
         "steps_taken": steps_taken,
-        "success": score >= task_info.get("passing_score", 0.6),
+        "success": final_score >= task_info.get("passing_score", 0.6),
         "episode_log": episode_log,
     }
 
@@ -350,7 +367,11 @@ def main():
 
     # ── Summary ───────────────────────────────────────────────────────────────
     elapsed = time.time() - start
-    mean_score = sum(r["score"] for r in results) / len(results) if results else 0.0
+    mean_score = (
+        sum(r["score"] for r in results) / len(results)
+        if results
+        else clamp_score_strict(0.0)
+    )
     passed = sum(1 for r in results if r["success"])
 
     print(f"\n{'═'*60}")
@@ -376,7 +397,8 @@ def main():
         "environment": "sre-incident-response",
         "results": results,
         "summary": {
-            "mean_score": round(mean_score, 4),
+            # Avoid rounding to 0.0/1.0; validator requires strict (0,1).
+            "mean_score": clamp_score_strict(mean_score),
             "tasks_passed": passed,
             "total_tasks": len(results),
             "elapsed_seconds": round(elapsed, 1),

inference.py

@@ -128,7 +128,7 @@ def emit_block(tag: str, payload: dict):
     safe_print(f"[{tag}] {line}")
 
 
-def clamp_score_strict(score: float, eps: float = 1e-3) -> float:
+def clamp_score_strict(score: float, eps: float = 0.01) -> float:
     """
     Hackathon validator requirement: scores must be strictly within (0, 1).
     Clamp away from endpoints to avoid returning exactly 0.0 or 1.0.
@@ -453,7 +453,11 @@ def run_task(
                     "parameters": parameters,
                     "reward": reward_val,
                     "done": done,
-                    "grader_score": step_data.get("info", {}).get("grader_score"),
+                    "grader_score": (
+                        clamp_score_strict(step_data.get("info", {}).get("grader_score"))
+                        if step_data.get("info", {}).get("grader_score") is not None
+                        else None
+                    ),
                 },
             )
 
@@ -599,13 +603,31 @@ def main():
         if not _wait_for_health(args.base_url, timeout_s=20.0):
             x = "✗" if UNICODE_OK else "x"
             safe_print(f"\n  {x} Environment not reachable at {args.base_url}")
+            # Some validators expect per-task scores even on failure. Emit placeholder
+            # task results with strictly (0,1) scores so the run is still parseable.
+            placeholder_results = [
+                {
+                    "task_id": tid,
+                    "task_name": tid,
+                    "difficulty": "?",
+                    "score": clamp_score_strict(0.0),
+                    "steps_taken": 0,
+                    "success": False,
+                    "episode_log": [{"error": f"Environment not reachable at {args.base_url}"}],
+                }
+                for tid in list(args.tasks)
+            ]
             emit_block(
                 "END",
                 {
                     "model": args.model,
                     "environment": "sre-incident-response",
-                    "results": [],
-                    "summary": {"mean_score": clamp_score_strict(0.0), "tasks_passed": 0, "total_tasks": 0},
+                    "results": placeholder_results,
+                    "summary": {
+                        "mean_score": clamp_score_strict(0.0),
+                        "tasks_passed": 0,
+                        "total_tasks": len(placeholder_results),
+                    },
                     "error": f"Environment not reachable at {args.base_url}",
                 },
             )
@@ -637,6 +659,7 @@ def main():
     # ── Summary ───────────────────────────────────────────────────────────────
     elapsed = time.time() - start
     mean_score = sum(r["score"] for r in results) / len(results) if results else clamp_score_strict(0.0)
+    mean_score = clamp_score_strict(mean_score)
     passed = sum(1 for r in results if r["success"])
 
     safe_print(f"\n{HR_THICK*60}")

server/app.py

@@ -226,13 +226,19 @@ async def baseline(request: BaselineRequest = Body(default=BaselineRequest())):
             max_steps=request.max_steps,
             task_ids=request.tasks,
         )
+
+        # Ensure validator-safe scores even if baseline errored or returned edge values.
+        safe_scores = [env_manager._clamp_score_strict(r.get("score", 0.0)) for r in results]
+        for r, s in zip(results, safe_scores):
+            r["score"] = s
+
         return {
             "model": request.model,
             "results": results,
             "summary": {
                 "mean_score": round(
-                    sum(r["score"] for r in results) / len(results), 4
-                ) if results else 0.0,
+                    sum(safe_scores) / len(safe_scores), 4
+                ) if safe_scores else env_manager._clamp_score_strict(0.0),
                 "tasks_passed": sum(
                     1 for r in results
                     if r["score"] >= TASK_REGISTRY[r["task_id"]].passing_score