corrected everytihng

env/graders.py

@@ -1,114 +1,92 @@
 import re
-import math
 from env.models import Action, DifficultyLevel
 from env.tasks import task_manager
 
-# ─────────────────────────────────────────────
-#  SCORE BOUNDS  (strictly between 0 and 1)
-# ─────────────────────────────────────────────
-SCORE_MIN = 0.001   # 0 < SCORE_MIN < 1
-SCORE_MAX = 0.999   # 0 < SCORE_MAX < 1
-
-
-def _clamp(value) -> float:
-    """
-    Guarantee the returned float is strictly inside (0, 1).
-    Handles NaN, Inf, None, strings, and any numeric type safely.
-    The round() call is applied AFTER the clamp, never before.
-    """
-    try:
-        v = float(value)
-    except (TypeError, ValueError):
-        return SCORE_MIN
-
-    # Guard against NaN and ±Inf before any comparison
-    if not math.isfinite(v):
-        return SCORE_MIN
-
-    clamped = max(min(v, SCORE_MAX), SCORE_MIN)
-    return round(clamped, 4)
-
-
 # ─────────────────────────────────────────────
 #  HELPERS
 # ─────────────────────────────────────────────
 
 def _normalize(text: str) -> str:
+    """Normalize SQL for comparison — lowercase, strip whitespace, collapse spaces."""
     if not isinstance(text, str):
         return ""
     return re.sub(r"\s+", " ", text.strip().lower())
 
-
 def _safe_get(payload: dict, key: str, default=None):
+    """Safe dict access — never KeyError."""
     if not isinstance(payload, dict):
         return default
     return payload.get(key, default)
 
-
 def _score_explanation(explanation: str) -> float:
+    """Score explanation quality by length and keyword richness."""
     if not explanation or not isinstance(explanation, str):
-        return SCORE_MIN
+        return 0.0
     explanation = explanation.strip()
     if len(explanation) < 10:
-        return SCORE_MIN
+        return 0.0
     if len(explanation) < 30:
         return 0.05
     if len(explanation) < 80:
         return 0.10
     return 0.15
 
-
 def _score_confidence(confidence) -> float:
+    """Give partial credit for providing a valid confidence score."""
     try:
         c = float(confidence)
-        if math.isfinite(c) and 0.0 <= c <= 1.0:
+        if 0.0 <= c <= 1.0:
             return 0.05
     except (TypeError, ValueError):
         pass
-    return SCORE_MIN
-
+    return 0.0
 
 def _query_similarity(submitted: str, expected: str) -> float:
+    """
+    Multi-level SQL similarity check.
+    Returns 0.0 - 1.0 based on how close the submitted query is to expected.
+    """
     s = _normalize(submitted)
     e = _normalize(expected)
 
     if s == e:
-        # Exact match — return SCORE_MAX, NOT 1.0
-        return SCORE_MAX
+        return 1.0
 
     s_tokens = set(s.split())
     e_tokens = set(e.split())
 
     if not e_tokens:
-        return SCORE_MIN
+        return 0.0
 
     overlap = len(s_tokens & e_tokens) / len(e_tokens)
 
     critical_keywords = _extract_critical_keywords(e)
     critical_found = sum(1 for kw in critical_keywords if kw in s)
-    critical_score = (critical_found / len(critical_keywords)
-                      if critical_keywords else 0.0)
-
-    raw = (overlap * 0.4) + (critical_score * 0.6)
-    return _clamp(raw)
+    critical_score = critical_found / len(critical_keywords) if critical_keywords else 0.0
 
+    return round((overlap * 0.4) + (critical_score * 0.6), 4)
 
-def _extract_critical_keywords(query: str) -> list:
+def _extract_critical_keywords(query: str) -> list[str]:
+    """Extract SQL keywords that are critical to correctness."""
     keywords = [
         "left join", "inner join", "right join",
         "group by", "order by", "having",
         "partition by", "coalesce", "distinct",
         "where", "on", "and", "or", "not",
         "count", "sum", "avg", "max", "min",
-        "select", "from", "join",
+        "select", "from", "join"
     ]
+    found = []
     q = query.lower()
-    return [kw for kw in keywords if kw in q]
-
+    for kw in keywords:
+        if kw in q:
+            found.append(kw)
+    return found
 
 def _score_error_type(submitted_type: str, expected_type: str) -> float:
+    """Score for correctly identifying the error type."""
     if not submitted_type:
-        return SCORE_MIN
+        return 0.0
     s = submitted_type.strip().lower()
     e = expected_type.strip().lower()
     if s == e:
@@ -116,54 +94,51 @@ def _score_error_type(submitted_type: str, expected_type: str) -> float:
     related = {
         "performance": ["optimization", "slow", "index", "scan"],
         "logic":       ["semantic", "incorrect", "wrong"],
-        "syntax":      ["parse", "grammar", "token"],
+        "syntax":      ["parse", "grammar", "token"]
     }
     for canonical, aliases in related.items():
         if e == canonical and any(alias in s for alias in aliases):
             return 0.05
-    return SCORE_MIN
-
+    return 0.0
 
-def _score_error_location(submitted_location: str,
-                          expected_location: str) -> float:
+def _score_error_location(submitted_location: str, expected_location: str) -> float:
+    """Score for correctly identifying WHERE in the query the error is."""
     if not submitted_location or not expected_location:
-        return SCORE_MIN
+        return 0.0
     s = submitted_location.strip().lower()
     e = expected_location.strip().lower()
     if s == e:
         return 0.15
     e_words = set(e.split())
     s_words = set(s.split())
-    if not e_words:
-        return SCORE_MIN
-    overlap = len(e_words & s_words) / len(e_words)
-    return _clamp(overlap * 0.10)
+    overlap = len(e_words & s_words) / len(e_words) if e_words else 0.0
+    return round(overlap * 0.10, 4)
 
 
 # ─────────────────────────────────────────────
-#  GRADERS
+#  GRADERS PER DIFFICULTY
 # ─────────────────────────────────────────────
 
-def grade_easy(action: Action, ground_truth: dict) -> tuple:
+def grade_easy(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
     """
-    Easy — syntax errors.
-    Scoring budget: fix(0.50) + loc(0.15) + type(0.10) + expl(0.15) + conf(0.05) = 0.95
+    Easy task grader — syntax errors.
+    Max score: 0.999 (strictly less than 1.0)
+    DETERMINISTIC: same input always returns same score.
     """
     if action is None or action.payload is None:
-        return SCORE_MIN, {"error": "null_action"}, "No action provided."
+        return 0.001, {"error": "null_action"}, "No action provided."
 
-    payload        = action.payload
-    score          = 0.0
-    breakdown      = {}
+    payload   = action.payload
+    score     = 0.0
+    breakdown = {}
     feedback_parts = []
 
-    # 1. Fix correctness (0.50)
-    submitted_query = (_safe_get(payload, "fixed_query", "")
-                       or _safe_get(payload, "optimized_query", "") or "")
+    # ── 1. Query fix correctness (0.50) ──────────────────────────
+    submitted_query = _safe_get(payload, "fixed_query", "") or _safe_get(payload, "optimized_query", "")
     expected_query  = ground_truth.get("fixed_query", "")
     similarity      = _query_similarity(submitted_query, expected_query)
 
-    if similarity >= SCORE_MAX:
+    if similarity >= 1.0:
         fix_score = 0.50
         feedback_parts.append("Correct fix applied.")
     elif similarity >= 0.75:
@@ -176,69 +151,67 @@ def grade_easy(action: Action, ground_truth: dict) -> tuple:
         fix_score = 0.0
         feedback_parts.append("Fix is incorrect or not provided.")
 
-    breakdown["fix_correctness"] = _clamp(fix_score)
     score += fix_score
-
-    # 2. Error location (0.15)
-    loc_score = _score_error_location(
-        str(_safe_get(payload, "error_location", "") or ""),
-        ground_truth.get("error_location", ""),
-    )
-    breakdown["error_location"] = _clamp(loc_score)
-    score += loc_score
-    if loc_score > SCORE_MIN:
+    breakdown["fix_correctness"] = round(fix_score, 4)
+
+    # ── 2. Error location (0.15) ─────────────────────────────────
+    submitted_location = _safe_get(payload, "error_location", "")
+    expected_location  = ground_truth.get("error_location", "")
+    loc_score          = _score_error_location(str(submitted_location), expected_location)
+    score             += loc_score
+    breakdown["error_location"] = round(loc_score, 4)
+    if loc_score > 0:
         feedback_parts.append("Correctly identified error location.")
 
-    # 3. Error type (0.10)
-    type_score = _score_error_type(
-        str(_safe_get(payload, "error_type", "") or ""),
-        ground_truth.get("error_type", "syntax"),
-    )
-    breakdown["error_type"] = _clamp(type_score)
-    score += type_score
-    if type_score > SCORE_MIN:
+    # ── 3. Error type (0.10) ─────────────────────────────────────
+    submitted_type = _safe_get(payload, "error_type", "")
+    expected_type  = ground_truth.get("error_type", "syntax")
+    type_score     = _score_error_type(str(submitted_type), expected_type)
+    score         += type_score
+    breakdown["error_type"] = round(type_score, 4)
+    if type_score > 0:
         feedback_parts.append("Correctly identified error type.")
 
-    # 4. Explanation quality (0.15)
-    explanation = (_safe_get(payload, "explanation", "")
-                   or _safe_get(payload, "change_made", "") or "")
-    expl_score  = _score_explanation(str(explanation))
-    breakdown["explanation"] = _clamp(expl_score)
-    score += expl_score
-    if expl_score > SCORE_MIN:
+    # ── 4. Explanation quality (0.15) ───────────��────────────────
+    explanation = _safe_get(payload, "explanation", "") or _safe_get(payload, "change_made", "")
+    expl_score  = _score_explanation(str(explanation) if explanation else "")
+    score      += expl_score
+    breakdown["explanation"] = round(expl_score, 4)
+    if expl_score > 0:
         feedback_parts.append("Explanation provided.")
 
-    # 5. Confidence (0.05)
-    conf_score = _score_confidence(_safe_get(payload, "confidence", None))
-    breakdown["confidence"] = _clamp(conf_score)
-    score += conf_score
+    # ── 5. Confidence (0.05) ─────────────────────────────────────
+    confidence = _safe_get(payload, "confidence", None)
+    conf_score = _score_confidence(confidence)
+    score     += conf_score
+    breakdown["confidence"] = round(conf_score, 4)
 
-    final_score = _clamp(score)
-    feedback    = " ".join(feedback_parts) or "No valid response provided."
+    # Clamp strictly between 0 and 1 exclusive
+    final_score = round(max(0.001, min(0.999, score)), 4)
+    feedback    = " ".join(feedback_parts) if feedback_parts else "No valid response provided."
     return final_score, breakdown, feedback
 
 
-def grade_medium(action: Action, ground_truth: dict) -> tuple:
+def grade_medium(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
     """
-    Medium — logic errors.
-    Scoring budget: fix(0.40) + logic(0.20) + loc(0.15) + expl(0.15)
-                    + conf(0.05) + impact(0.05) = 1.00  -> clamped to SCORE_MAX
+    Medium task grader — logic errors.
+    Max score: 0.999 (strictly less than 1.0)
+    DETERMINISTIC: same input always returns same score.
     """
     if action is None or action.payload is None:
-        return SCORE_MIN, {"error": "null_action"}, "No action provided."
+        return 0.001, {"error": "null_action"}, "No action provided."
 
     payload        = action.payload
     score          = 0.0
     breakdown      = {}
     feedback_parts = []
 
-    # 1. Fix correctness (0.40)
-    submitted_query = (_safe_get(payload, "fixed_query", "")
-                       or _safe_get(payload, "optimized_query", "") or "")
+    # ── 1. Query fix correctness (0.40) ──────────────────────────
+    submitted_query = _safe_get(payload, "fixed_query", "") or _safe_get(payload, "optimized_query", "")
     expected_query  = ground_truth.get("fixed_query", "")
     similarity      = _query_similarity(submitted_query, expected_query)
 
-    if similarity >= SCORE_MAX:
+    if similarity >= 1.0:
         fix_score = 0.40
         feedback_parts.append("Correct fix applied.")
     elif similarity >= 0.80:
@@ -254,84 +227,86 @@ def grade_medium(action: Action, ground_truth: dict) -> tuple:
         fix_score = 0.0
         feedback_parts.append("Fix is incorrect or missing.")
 
-    breakdown["fix_correctness"] = _clamp(fix_score)
     score += fix_score
+    breakdown["fix_correctness"] = round(fix_score, 4)
 
-    # 2. Logic flaw identification (0.20)
-    explanation = str(_safe_get(payload, "explanation", "")
-                      or _safe_get(payload, "change_made", "") or "")
+    # ── 2. Logic flaw identification (0.20) ──────────────────────
+    explanation = str(_safe_get(payload, "explanation", "") or _safe_get(payload, "change_made", "") or "")
     error_type  = ground_truth.get("error_type", "logic")
 
     logic_keywords = {
-        "logic": ["join", "left join", "inner join", "having", "where",
-                  "group by", "aggregate", "subquery", "correlation",
-                  "distinct", "count"],
-        "performance": ["index", "scan", "n+1", "correlated",
-                        "cartesian", "window"],
+        "logic":       ["join", "left join", "inner join", "having", "where", "group by",
+                        "aggregate", "subquery", "correlation", "distinct", "count"],
+        "performance": ["index", "scan", "n+1", "correlated", "cartesian", "window"]
     }
+
     keywords_to_check = logic_keywords.get(error_type, logic_keywords["logic"])
     expl_lower        = explanation.lower()
     keyword_hits      = sum(1 for kw in keywords_to_check if kw in expl_lower)
-    logic_score       = _clamp(min(keyword_hits * 0.05, 0.20))
-    breakdown["logic_flaw_identification"] = _clamp(logic_score)
-    score += logic_score
-    if logic_score > SCORE_MIN:
+    logic_score       = min(keyword_hits * 0.05, 0.20)
+    score            += logic_score
+    breakdown["logic_flaw_identification"] = round(logic_score, 4)
+    if logic_score > 0:
         feedback_parts.append("Shows understanding of the logic flaw.")
 
-    # 3. Error location (0.15)
-    loc_score = _score_error_location(
-        str(_safe_get(payload, "error_location", "") or ""),
-        ground_truth.get("error_location", ""),
-    )
-    breakdown["error_location"] = _clamp(loc_score)
-    score += loc_score
+    # ── 3. Error location (0.15) ─────────────────────────────────
+    submitted_location = _safe_get(payload, "error_location", "")
+    expected_location  = ground_truth.get("error_location", "")
+    loc_score          = _score_error_location(str(submitted_location), expected_location)
+    score             += loc_score
+    breakdown["error_location"] = round(loc_score, 4)
 
-    # 4. Explanation quality (0.15)
+    # ── 4. Explanation quality (0.15) ────────────────────────────
     expl_score = _score_explanation(explanation)
-    breakdown["explanation"] = _clamp(expl_score)
-    score += expl_score
+    score     += expl_score
+    breakdown["explanation"] = round(expl_score, 4)
 
-    # 5. Confidence (0.05)
-    conf_score = _score_confidence(_safe_get(payload, "confidence", None))
-    breakdown["confidence"] = _clamp(conf_score)
-    score += conf_score
+    # ── 5. Confidence (0.05) ─────────────────────────────────────
+    confidence = _safe_get(payload, "confidence", None)
+    conf_score = _score_confidence(confidence)
+    score     += conf_score
+    breakdown["confidence"] = round(conf_score, 4)
 
-    # 6. Impact analysis bonus (0.05)
+    # ── 6. Impact analysis bonus (0.05) ──────────────────────────
     impact = str(_safe_get(payload, "impact", "") or "")
-    impact_score = 0.05 if len(impact.strip()) > 20 else 0.0
-    breakdown["impact_analysis"] = _clamp(impact_score)
-    score += impact_score
-    if impact_score > 0:
+    if len(impact.strip()) > 20:
+        score += 0.05
+        breakdown["impact_analysis"] = 0.05
         feedback_parts.append("Impact analysis provided.")
+    else:
+        breakdown["impact_analysis"] = 0.0
 
-    final_score = _clamp(score)
-    feedback    = " ".join(feedback_parts) or "No valid response provided."
+    # Clamp strictly between 0 and 1 exclusive
+    final_score = round(max(0.001, min(0.999, score)), 4)
+    feedback    = " ".join(feedback_parts) if feedback_parts else "No valid response provided."
     return final_score, breakdown, feedback
 
 
-def grade_hard(action: Action, ground_truth: dict) -> tuple:
+def grade_hard(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
     """
-    Hard — performance issues (N+1, missing index, cartesian, etc).
-    Scoring budget: query(0.30) + concept(0.30) + expl(0.15)
-                    + root(0.10) + improvement(0.10) + conf(0.05) = 1.00 -> clamped
+    Hard task grader — performance issues.
+    Max score: 0.999 (strictly less than 1.0)
+    Frontier models expected ~0.10-0.20.
+    DETERMINISTIC: same input always returns same score.
     """
     if action is None or action.payload is None:
-        return SCORE_MIN, {"error": "null_action"}, "No action provided."
+        return 0.001, {"error": "null_action"}, "No action provided."
 
-    # All variables initialised before first use
     payload        = action.payload
     score          = 0.0
     breakdown      = {}
     feedback_parts = []
-    _rubric        = ground_truth.get("scoring_rubric", {})  # reserved for future use
 
-    # 1. Query correctness (0.30)
-    submitted_query = (_safe_get(payload, "optimized_query", "")
-                       or _safe_get(payload, "fixed_query", "") or "")
-    expected_query  = ground_truth.get("fixed_query", "")
-    similarity      = _query_similarity(submitted_query, expected_query)
+    # ── 1. Query correctness (0.30) ──────────────────────────────
+    submitted_query = (
+        _safe_get(payload, "optimized_query", "")
+        or _safe_get(payload, "fixed_query", "")
+        or ""
+    )
+    expected_query = ground_truth.get("fixed_query", "")
+    similarity     = _query_similarity(submitted_query, expected_query)
 
-    if similarity >= SCORE_MAX:
+    if similarity >= 1.0:
         fix_score = 0.30
         feedback_parts.append("Perfectly optimized query.")
     elif similarity >= 0.85:
@@ -347,75 +322,70 @@ def grade_hard(action: Action, ground_truth: dict) -> tuple:
         fix_score = 0.0
         feedback_parts.append("Query does not address the performance issue.")
 
-    breakdown["query_correctness"] = _clamp(fix_score)
     score += fix_score
+    breakdown["query_correctness"] = round(fix_score, 4)
 
-    # 2. Performance concept identification (0.30)
-    explanation   = str(_safe_get(payload, "explanation", "")
-                        or _safe_get(payload, "change_made", "") or "")
+    # ── 2. Performance concept identification (0.30) ──────────────
+    explanation   = str(_safe_get(payload, "explanation", "") or _safe_get(payload, "change_made", "") or "")
     optimization  = str(_safe_get(payload, "optimization_type", "") or "")
     combined_text = (explanation + " " + optimization).lower()
     perf_issue    = ground_truth.get("performance_issue", {})
-    issue_type    = (perf_issue.get("type", "").lower()
-                     if isinstance(perf_issue, dict) else "")
+    issue_type    = perf_issue.get("type", "").lower()
 
     performance_concept_map = {
-        "n+1":               ["n+1", "correlated subquery", "subquery per row",
-                               "multiple queries", "join instead"],
-        "full table scan":   ["full table scan", "index not used",
-                               "function on column", "sargable",
-                               "range scan", "seek"],
-        "cartesian product": ["cartesian", "cross join",
-                               "missing join condition",
-                               "implicit join", "comma join"],
-        "select *":          ["select *", "over-fetch", "covering index",
-                               "column projection", "unnecessary columns"],
-        "window function":   ["window function", "partition by", "row_number",
-                               "subquery filter", "where clause window"],
+        "n+1":               ["n+1", "correlated subquery", "subquery per row", "multiple queries", "join instead"],
+        "full table scan":   ["full table scan", "index not used", "function on column", "sargable", "range scan", "seek"],
+        "cartesian product": ["cartesian", "cross join", "missing join condition", "implicit join", "comma join"],
+        "select *":          ["select *", "over-fetch", "covering index", "column projection", "unnecessary columns"],
+        "window function":   ["window function", "partition by", "row_number", "subquery filter", "where clause window"]
     }
 
     concept_score = 0.0
     for concept, keywords in performance_concept_map.items():
-        if any(part in issue_type for part in concept.split()):
+        if any(concept_part in issue_type for concept_part in concept.split()):
             hits = sum(1 for kw in keywords if kw in combined_text)
             concept_score = min(hits * 0.06, 0.30)
             break
 
-    breakdown["performance_concept"] = _clamp(concept_score)
     score += concept_score
+    breakdown["performance_concept"] = round(concept_score, 4)
     if concept_score > 0:
         feedback_parts.append("Demonstrates understanding of the performance issue.")
 
-    # 3. Explanation depth (0.15)
+    # ── 3. Explanation depth (0.15) ───────────────────────────────
     expl_score = _score_explanation(explanation)
     if len(explanation.strip()) > 150:
         expl_score = min(expl_score + 0.05, 0.15)
-    breakdown["explanation_depth"] = _clamp(expl_score)
     score += expl_score
+    breakdown["explanation_depth"] = round(expl_score, 4)
 
-    # 4. Root cause analysis (0.10)
+    # ── 4. Root cause analysis (0.10) ─────────────────────────────
     root_cause = str(_safe_get(payload, "root_cause", "") or "")
-    root_score = 0.10 if len(root_cause.strip()) > 30 else 0.0
-    breakdown["root_cause_analysis"] = _clamp(root_score)
-    score += root_score
-    if root_score > 0:
+    if len(root_cause.strip()) > 30:
+        score += 0.10
+        breakdown["root_cause_analysis"] = 0.10
         feedback_parts.append("Root cause analysis provided.")
+    else:
+        breakdown["root_cause_analysis"] = 0.0
 
-    # 5. Expected improvement (0.10)
+    # ── 5. Expected improvement (0.10) ────────────────────────────
     improvement = str(_safe_get(payload, "expected_improvement", "") or "")
-    imp_score = 0.10 if len(improvement.strip()) > 20 else 0.0
-    breakdown["expected_improvement"] = _clamp(imp_score)
-    score += imp_score
-    if imp_score > 0:
+    if len(improvement.strip()) > 20:
+        score += 0.10
+        breakdown["expected_improvement"] = 0.10
         feedback_parts.append("Performance improvement estimate provided.")
+    else:
+        breakdown["expected_improvement"] = 0.0
 
-    # 6. Confidence (0.05)
-    conf_score = _score_confidence(_safe_get(payload, "confidence", None))
-    breakdown["confidence"] = _clamp(conf_score)
-    score += conf_score
+    # ── 6. Confidence (0.05) ──────────────────────────────────────
+    confidence = _safe_get(payload, "confidence", None)
+    conf_score = _score_confidence(confidence)
+    score     += conf_score
+    breakdown["confidence"] = round(conf_score, 4)
 
-    final_score = _clamp(score)
-    feedback    = " ".join(feedback_parts) or "Performance issue not identified."
+    # Clamp strictly between 0 and 1 exclusive
+    final_score = round(max(0.001, min(0.999, score)), 4)
+    feedback    = " ".join(feedback_parts) if feedback_parts else "Performance issue not identified."
     return final_score, breakdown, feedback
 
 
@@ -423,40 +393,30 @@ def grade_hard(action: Action, ground_truth: dict) -> tuple:
 #  MAIN GRADER DISPATCHER
 # ─────────────────���───────────────────────────
 
-def grade(action: Action, task_id: str) -> tuple:
+def grade(action: Action, task_id: str) -> tuple[float, dict, str]:
     """
-    Main entry point.  Always returns (float, dict, str) — never crashes.
-    The returned float is always strictly inside (0, 1).
+    Main grader entry point.
+    Looks up ground truth, dispatches to correct grader by difficulty.
+    ALWAYS returns (float, dict, str) — never crashes.
+    Score is always strictly between 0.001 and 0.999.
     """
     if action is None:
-        return SCORE_MIN, {"error": "null_action"}, "No action provided."
+        return 0.001, {"error": "null_action"}, "No action provided."
 
     ground_truth = task_manager.get_ground_truth(task_id)
     if ground_truth is None:
-        return SCORE_MIN, {"error": "unknown_task"}, f"Task '{task_id}' not found."
+        return 0.001, {"error": "unknown_task"}, f"Task '{task_id}' not found."
 
     difficulty = ground_truth.get("id", "").split("_")[0]
 
     try:
         if difficulty == "easy":
-            result = grade_easy(action, ground_truth)
+            return grade_easy(action, ground_truth)
         elif difficulty == "medium":
-            result = grade_medium(action, ground_truth)
+            return grade_medium(action, ground_truth)
         elif difficulty == "hard":
-            result = grade_hard(action, ground_truth)
+            return grade_hard(action, ground_truth)
         else:
-            return (SCORE_MIN,
-                    {"error": "unknown_difficulty"},
-                    f"Unknown difficulty: {difficulty}")
-
-        # Final safety net: re-clamp the returned score and every breakdown value
-        final_score, breakdown, feedback = result
-        safe_score     = _clamp(final_score)
-        safe_breakdown = {
-            k: _clamp(v) if isinstance(v, (int, float)) else v
-            for k, v in breakdown.items()
-        }
-        return safe_score, safe_breakdown, feedback
-
+            return 0.001, {"error": "unknown_difficulty"}, f"Unknown difficulty: {difficulty}"
     except Exception as e:
-        return SCORE_MIN, {"error": str(e)}, f"Grader error: {str(e)}"
+        return 0.001, {"error": str(e)}, f"Grader error: {str(e)}"

inference.py

@@ -11,10 +11,11 @@ from typing import List, Optional
 
 from openai import OpenAI
 from dotenv import load_dotenv
-load_dotenv() 
+load_dotenv()
 
 from env.environment import SQLDebuggerEnvironment
 from env.models import Action, ActionType, DifficultyLevel
+
 # ─────────────────────────────────────────────
 #  ENVIRONMENT VARIABLES
 # ─────────────────────────────────────────────
@@ -25,20 +26,34 @@ HF_TOKEN     = os.getenv("HF_TOKEN")
 if HF_TOKEN is None:
     raise ValueError("HF_TOKEN environment variable is required")
 
-API_KEY = HF_TOKEN
-BENCHMARK    = "sql-query-debugger"
-MAX_STEPS    = 10
+API_KEY           = HF_TOKEN
+BENCHMARK         = "sql-query-debugger"
+MAX_STEPS         = 10
 SUCCESS_SCORE_THRESHOLD = 0.5
+
+# ─────────────────────────────────────────────
+#  LOGGING FUNCTIONS
 # ─────────────────────────────────────────────
 
 def log_start(task: str, env: str, model: str) -> None:
     print(f"[START] task={task} env={env} model={model}", flush=True)
 
 
-def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val  = str(done).lower()
+    print(f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}", flush=True)
+
+
+def log_end(success: bool, steps: int, rewards: List[float]) -> None:
     rewards_str = ",".join(f"{r:.2f}" for r in rewards)
     print(f"[END] success={str(success).lower()} steps={steps} rewards={rewards_str}", flush=True)
 
+
+# ─────────────────────────────────────────────
+#  SYSTEM PROMPT
+# ─────────────────────────────────────────────
+
 SYSTEM_PROMPT = textwrap.dedent("""
     You are an expert SQL debugger. You will be given a buggy SQL query and must fix it.
 
@@ -113,7 +128,6 @@ def get_llm_action(client: OpenAI, obs, step: int) -> Action:
         )
         text = (completion.choices[0].message.content or "").strip()
 
-        # Parse JSON response
         # Remove markdown code blocks if present
         if "```" in text:
             text = text.split("```")[1]
@@ -150,7 +164,6 @@ def get_llm_action(client: OpenAI, obs, step: int) -> Action:
 
     except Exception as exc:
         print(f"[DEBUG] LLM call failed: {exc}", flush=True)
-        # Fallback to identify_error action
         return Action(
             action_type=ActionType.IDENTIFY_ERROR,
             payload={
@@ -162,17 +175,17 @@ def get_llm_action(client: OpenAI, obs, step: int) -> Action:
 
 
 # ─────────────────────────────────────────────
-#  MAIN INFERENCE LOOP
+#  EPISODE RUNNER
 # ─────────────────────────────────────────────
 
 def run_episode(client: OpenAI, difficulty: str, task_id: str) -> dict:
     """Run one full episode and return results."""
-    env      = SQLDebuggerEnvironment()
-    obs      = env.reset(difficulty=difficulty, task_id=task_id)
-    rewards  = []
-    steps    = 0
-    success  = False
-    score    = 0.001  # Initialize to minimum valid score
+    env     = SQLDebuggerEnvironment()
+    obs     = env.reset(difficulty=difficulty, task_id=task_id)
+    rewards = []
+    steps   = 0
+    success = False
+    score   = 0.0
 
     log_start(task=task_id, env=BENCHMARK, model=MODEL_NAME)
 
@@ -181,10 +194,9 @@ def run_episode(client: OpenAI, difficulty: str, task_id: str) -> dict:
             if env.state().done:
                 break
 
-            # Get action from LLM
-            action       = get_llm_action(client, obs, step)
-            action_str   = f"{action.action_type.value}"
-            error_str    = None
+            action     = get_llm_action(client, obs, step)
+            action_str = action.action_type.value
+            error_str  = None
 
             try:
                 resp   = env.step(action)
@@ -192,8 +204,8 @@ def run_episode(client: OpenAI, difficulty: str, task_id: str) -> dict:
                 done   = resp.done
                 obs    = resp.observation
             except Exception as e:
-                reward   = -0.1
-                done     = False
+                reward    = -0.1
+                done      = False
                 error_str = str(e)[:100]
 
             rewards.append(reward)
@@ -210,20 +222,22 @@ def run_episode(client: OpenAI, difficulty: str, task_id: str) -> dict:
             if done:
                 break
 
-        # Calculate score
+        # Score must be strictly between 0 and 1 (not 0.0, not 1.0)
         total_reward = sum(rewards)
-        score        = min(max(total_reward / MAX_STEPS, 0.001), 0.999)
-        success      = score >= SUCCESS_SCORE_THRESHOLD
+        raw_score    = total_reward / MAX_STEPS if MAX_STEPS > 0 else 0.0
+        # Clamp strictly between 0 and 1 exclusive
+        score   = max(0.001, min(0.999, raw_score))
+        success = score >= SUCCESS_SCORE_THRESHOLD
 
     except Exception as e:
         print(f"[DEBUG] Episode error: {e}", flush=True)
-        error_str = str(e)[:100]
+        score   = 0.001
+        success = False
 
     finally:
         log_end(
             success = success,
             steps   = steps,
-            score   = score,
             rewards = rewards
         )
 
@@ -236,6 +250,10 @@ def run_episode(client: OpenAI, difficulty: str, task_id: str) -> dict:
     }
 
 
+# ─────────────────────────────────────────────
+#  MAIN
+# ─────────────────────────────────────────────
+
 def main():
     """Main entry point — runs inference on all 3 difficulty levels."""
     print(f"[DEBUG] API_BASE_URL={API_BASE_URL}", flush=True)
@@ -254,7 +272,6 @@ def main():
         result = run_episode(client, difficulty, task_id)
         results.append(result)
 
-    # Final summary
     avg_score = sum(r["score"] for r in results) / len(results)
     print(f"\n[DEBUG] Average Score: {avg_score:.3f}", flush=True)
     for r in results: