fix: add 3 tasks with graders and grade endpoint

server/app.py

@@ -32,7 +32,9 @@ Usage:
     python -m server.app
 """
 from __future__ import annotations
+from fastapi import HTTPException, Request
 from openenv.core.env_server.http_server import create_app
+
 try:
     from ..models import IncidentopsAction, IncidentopsObservation
     from incidentops_env_environment import IncidentopsEnvironment
@@ -40,17 +42,37 @@ except Exception:
     from models import IncidentopsAction, IncidentopsObservation
     from server.incidentops_env_environment import IncidentopsEnvironment
 
+
+# ✅ Single shared env instance used by BOTH create_app and /grade
+_shared_env = IncidentopsEnvironment()
+
 app = create_app(
-    IncidentopsEnvironment,
+    lambda: _shared_env,   # ← pass a factory that returns same instance
     IncidentopsAction,
     IncidentopsObservation,
     env_name="incidentops_env",
     max_concurrent_envs=1,
 )
 
+
+@app.post("/grade")
+@app.get("/grade")
+async def grade_endpoint():
+    try:
+        return _shared_env.grade()
+    except AssertionError:
+        raise HTTPException(
+            status_code=400,
+            detail="No active episode. Call /reset first."
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 def main(host: str = "0.0.0.0", port: int = 7860) -> None:
     import uvicorn
     uvicorn.run(app, host=host, port=port)
 
+
 if __name__ == "__main__":
     main()

server/incidentops_env_environment.py

@@ -281,29 +281,32 @@ class IncidentopsEnvironment(Environment):
         assert self._snapshot is not None
         s = self._snapshot
 
-        # Compute normalized score 0.0 - 1.0
-        total_steps = s.step_count or 1
+        total_steps = max(s.step_count, 1)  # ✅ used below
         sla_ok = s.step_count <= s.sla_steps
         correct_actions = sum(
             1 for a in s.action_history if a in s.correct_action_sequence
         )
         correctness_ratio = correct_actions / max(len(s.correct_action_sequence), 1)
 
+        # ✅ efficiency bonus — fewer steps = better score
+        efficiency_bonus = max(0.0, (s.sla_steps - total_steps) / s.sla_steps)
+
         if s.resolved and sla_ok:
-            score = min(1.0, 0.5 + 0.5 * correctness_ratio)
+            score = min(1.0, 0.5 + 0.3 * correctness_ratio + 0.2 * efficiency_bonus)
         elif s.resolved:
             score = min(0.6, 0.3 + 0.3 * correctness_ratio)
         else:
             score = max(0.0, 0.1 * correctness_ratio)
 
         return {
-        "score": round(score, 4),
-        "success": s.resolved and sla_ok,
-        "incident_resolved": s.resolved,
-        "steps_taken": s.step_count,
-        "sla_met": sla_ok,
-        "wrong_escalations": s.wrong_escalations,
-        "evidence_collected": s.evidence_collected,
+            "score": round(score, 4),
+            "success": s.resolved and sla_ok,
+            "incident_resolved": s.resolved,
+            "steps_taken": s.step_count,
+            "sla_met": sla_ok,
+            "efficiency_bonus": round(efficiency_bonus, 4),
+            "wrong_escalations": s.wrong_escalations,
+            "evidence_collected": s.evidence_collected,
         }
     @property
     def state(self) -> State: