again fixed graders

env/graders.py

@@ -1,31 +1,51 @@
 import re
+import math
 from env.models import Action, DifficultyLevel
 from env.tasks import task_manager
 
-#  HELPERS
+# ─────────────────────────────────────────────
+#  SCORE BOUNDS  (strictly between 0 and 1)
+# ─────────────────────────────────────────────
+SCORE_MIN = 0.001   # 0 < SCORE_MIN < 1
+SCORE_MAX = 0.999   # 0 < SCORE_MAX < 1
 
-SCORE_MIN = 0.001
-SCORE_MAX = 0.999
 
-def _clamp(value: float) -> float:
-    """Clamp a score to strictly (0, 1) — never 0.0 or 1.0."""
-    return round(max(min(float(value), SCORE_MAX), SCORE_MIN), 4)
+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
     explanation = explanation.strip()
@@ -37,31 +57,25 @@ def _score_explanation(explanation: str) -> float:
         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 0.0 <= c <= 1.0:
+        if math.isfinite(c) and 0.0 <= c <= 1.0:
             return 0.05
     except (TypeError, ValueError):
         pass
     return SCORE_MIN
 
+
 def _query_similarity(submitted: str, expected: str) -> float:
-    """
-    Multi-level SQL similarity check.
-    Returns SCORE_MIN - SCORE_MAX based on how close the submitted query is to expected.
-    Handles case, whitespace, and keyword-level matching.
-    """
     s = _normalize(submitted)
     e = _normalize(expected)
 
-    # Exact match after normalization
-    # NOTE: max similarity is SCORE_MAX (0.999), so threshold must be <= SCORE_MAX
     if s == e:
+        # Exact match — return SCORE_MAX, NOT 1.0
         return SCORE_MAX
 
-    # Tokenize and check keyword overlap
     s_tokens = set(s.split())
     e_tokens = set(e.split())
 
@@ -70,89 +84,85 @@ def _query_similarity(submitted: str, expected: str) -> float:
 
     overlap = len(s_tokens & e_tokens) / len(e_tokens)
 
-    # Check critical keywords present
     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
+    critical_score = (critical_found / len(critical_keywords)
+                      if critical_keywords else 0.0)
+
+    raw = (overlap * 0.4) + (critical_score * 0.6)
+    return _clamp(raw)
 
-    # Weighted combination
-    similarity = round((overlap * 0.4) + (critical_score * 0.6), 4)
-    return _clamp(similarity)
 
-def _extract_critical_keywords(query: str) -> list[str]:
-    """Extract SQL keywords that are critical to correctness."""
+def _extract_critical_keywords(query: str) -> list:
     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()
-    for kw in keywords:
-        if kw in q:
-            found.append(kw)
-    return found
+    return [kw for kw in keywords if kw in q]
+
 
 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
     s = submitted_type.strip().lower()
     e = expected_type.strip().lower()
     if s == e:
         return 0.10
-    # Partial: performance ↔ optimization are related
     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
 
-def _score_error_location(submitted_location: str, expected_location: str) -> float:
-    """Score for correctly identifying WHERE in the query the error is."""
+
+def _score_error_location(submitted_location: str,
+                          expected_location: str) -> float:
     if not submitted_location or not expected_location:
         return SCORE_MIN
     s = submitted_location.strip().lower()
     e = expected_location.strip().lower()
     if s == e:
         return 0.15
-    # Partial: check if key location words overlap
     e_words = set(e.split())
     s_words = set(s.split())
-    overlap = len(e_words & s_words) / len(e_words) if e_words else 0.0
+    if not e_words:
+        return SCORE_MIN
+    overlap = len(e_words & s_words) / len(e_words)
     return _clamp(overlap * 0.10)
 
 
-#  GRADERS PER DIFFICULTY
+# ─────────────────────────────────────────────
+#  GRADERS
+# ─────────────────────────────────────────────
 
-def grade_easy(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
+def grade_easy(action: Action, ground_truth: dict) -> tuple:
     """
-    Easy task grader — syntax errors.
-    Max score: SCORE_MAX
-    Partial credit across: fix correctness, error location, error type, explanation, confidence.
-    DETERMINISTIC: same input always returns same score.
+    Easy — syntax errors.
+    Scoring budget: fix(0.50) + loc(0.15) + type(0.10) + expl(0.15) + conf(0.05) = 0.95
     """
     if action is None or action.payload is None:
         return SCORE_MIN, {"error": "null_action"}, "No action provided."
 
-    payload = action.payload
-    score   = 0.0
-    breakdown = {}
+    payload        = action.payload
+    score          = 0.0
+    breakdown      = {}
     feedback_parts = []
 
-    # ── 1. Query fix correctness (0.50) ──────────────────────────
-    submitted_query = _safe_get(payload, "fixed_query", "") or _safe_get(payload, "optimized_query", "")
+    # 1. Fix correctness (0.50)
+    submitted_query = (_safe_get(payload, "fixed_query", "")
+                       or _safe_get(payload, "optimized_query", "") or "")
     expected_query  = ground_truth.get("fixed_query", "")
     similarity      = _query_similarity(submitted_query, expected_query)
 
-    # Threshold uses SCORE_MAX (0.999) since that is the exact-match ceiling
     if similarity >= SCORE_MAX:
         fix_score = 0.50
         feedback_parts.append("Correct fix applied.")
@@ -166,63 +176,65 @@ def grade_easy(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
         fix_score = 0.0
         feedback_parts.append("Fix is incorrect or not provided.")
 
+    breakdown["fix_correctness"] = _clamp(fix_score)
     score += fix_score
-    breakdown["fix_correctness"] = _clamp(fix_score) if fix_score > 0 else SCORE_MIN
 
-    # ── 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
+    # 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:
         feedback_parts.append("Correctly identified error location.")
 
-    # ── 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
+    # 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:
         feedback_parts.append("Correctly identified error type.")
 
-    # ── 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
+    # 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:
         feedback_parts.append("Explanation provided.")
 
-    # ── 5. Confidence (0.05) ─────────────────────────────────────
-    confidence   = _safe_get(payload, "confidence", None)
-    conf_score   = _score_confidence(confidence)
-    score       += conf_score
+    # 5. Confidence (0.05)
+    conf_score = _score_confidence(_safe_get(payload, "confidence", None))
     breakdown["confidence"] = _clamp(conf_score)
+    score += conf_score
 
     final_score = _clamp(score)
-    feedback    = " ".join(feedback_parts) if feedback_parts else "No valid response provided."
+    feedback    = " ".join(feedback_parts) or "No valid response provided."
     return final_score, breakdown, feedback
 
 
-def grade_medium(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
+def grade_medium(action: Action, ground_truth: dict) -> tuple:
     """
-    Medium task grader — logic errors (wrong JOINs, wrong aggregations, etc).
-    Max score: SCORE_MAX
-    Higher bar: must correctly identify the logic flaw, not just syntax.
-    DETERMINISTIC: same input always returns same score.
+    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
     """
     if action is None or action.payload is None:
         return SCORE_MIN, {"error": "null_action"}, "No action provided."
 
-    payload   = action.payload
-    score     = 0.0
-    breakdown = {}
+    payload        = action.payload
+    score          = 0.0
+    breakdown      = {}
     feedback_parts = []
 
-    # ── 1. Query fix correctness (0.40) ──────────────────────────
-    submitted_query = _safe_get(payload, "fixed_query", "") or _safe_get(payload, "optimized_query", "")
+    # 1. Fix correctness (0.40)
+    submitted_query = (_safe_get(payload, "fixed_query", "")
+                       or _safe_get(payload, "optimized_query", "") or "")
     expected_query  = ground_truth.get("fixed_query", "")
     similarity      = _query_similarity(submitted_query, expected_query)
 
@@ -242,85 +254,82 @@ def grade_medium(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
         fix_score = 0.0
         feedback_parts.append("Fix is incorrect or missing.")
 
+    breakdown["fix_correctness"] = _clamp(fix_score)
     score += fix_score
-    breakdown["fix_correctness"] = _clamp(fix_score) if fix_score > 0 else SCORE_MIN
 
-    # ── 2. Identifies the logic flaw (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))
-    score            += logic_score
     breakdown["logic_flaw_identification"] = _clamp(logic_score)
+    score += logic_score
     if logic_score > SCORE_MIN:
         feedback_parts.append("Shows understanding of the logic flaw.")
 
-    # ── 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
+    # 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
 
-    # ── 4. Explanation quality (0.15) ────────────────────────────
+    # 4. Explanation quality (0.15)
     expl_score = _score_explanation(explanation)
-    score     += expl_score
     breakdown["explanation"] = _clamp(expl_score)
+    score += expl_score
 
-    # ── 5. Confidence (0.05) ─────────────────────────────────────
-    confidence = _safe_get(payload, "confidence", None)
-    conf_score = _score_confidence(confidence)
-    score     += conf_score
+    # 5. Confidence (0.05)
+    conf_score = _score_confidence(_safe_get(payload, "confidence", None))
     breakdown["confidence"] = _clamp(conf_score)
+    score += conf_score
 
-    # ── 6. Impact analysis bonus (0.05) ──────────────────────────
+    # 6. Impact analysis bonus (0.05)
     impact = str(_safe_get(payload, "impact", "") or "")
-    if len(impact.strip()) > 20:
-        score += 0.05
-        breakdown["impact_analysis"] = 0.05
+    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:
         feedback_parts.append("Impact analysis provided.")
-    else:
-        breakdown["impact_analysis"] = SCORE_MIN
 
     final_score = _clamp(score)
-    feedback    = " ".join(feedback_parts) if feedback_parts else "No valid response provided."
+    feedback    = " ".join(feedback_parts) or "No valid response provided."
     return final_score, breakdown, feedback
 
 
-def grade_hard(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
+def grade_hard(action: Action, ground_truth: dict) -> tuple:
     """
-    Hard task grader — performance issues (N+1, missing index, cartesian, etc).
-    Max score: SCORE_MAX but frontier models expected ~0.10-0.20.
-    Extremely strict — requires deep understanding of performance concepts.
-    DETERMINISTIC: same input always returns same score.
+    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
     """
     if action is None or action.payload is None:
         return SCORE_MIN, {"error": "null_action"}, "No action provided."
 
-    # ── FIX: initialize all variables before use ──────────────────
+    # All variables initialised before first use
     payload        = action.payload
     score          = 0.0
     breakdown      = {}
     feedback_parts = []
-    rubric         = ground_truth.get("scoring_rubric", {})
+    _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:
         fix_score = 0.30
@@ -338,69 +347,75 @@ def grade_hard(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
         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"] = _clamp(fix_score) if fix_score > 0 else SCORE_MIN
 
-    # ── 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()
+    # 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 "")
 
     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 = SCORE_MIN
+    concept_score = 0.0
     for concept, keywords in performance_concept_map.items():
-        if any(concept_part in issue_type for concept_part in concept.split()):
+        if any(part in issue_type for part in concept.split()):
             hits = sum(1 for kw in keywords if kw in combined_text)
-            concept_score = _clamp(min(hits * 0.06, 0.30))
+            concept_score = min(hits * 0.06, 0.30)
             break
 
-    score += concept_score
     breakdown["performance_concept"] = _clamp(concept_score)
-    if concept_score > SCORE_MIN:
+    score += concept_score
+    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)
-    score += expl_score
     breakdown["explanation_depth"] = _clamp(expl_score)
+    score += expl_score
 
-    # ── 4. Root cause analysis (0.10) ─────────────────────────────
+    # 4. Root cause analysis (0.10)
     root_cause = str(_safe_get(payload, "root_cause", "") or "")
-    if len(root_cause.strip()) > 30:
-        score += 0.10
-        breakdown["root_cause_analysis"] = 0.10
+    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:
         feedback_parts.append("Root cause analysis provided.")
-    else:
-        breakdown["root_cause_analysis"] = SCORE_MIN
 
-    # ── 5. Expected improvement (0.10) ────────────────────────────
+    # 5. Expected improvement (0.10)
     improvement = str(_safe_get(payload, "expected_improvement", "") or "")
-    if len(improvement.strip()) > 20:
-        score += 0.10
-        breakdown["expected_improvement"] = 0.10
+    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:
         feedback_parts.append("Performance improvement estimate provided.")
-    else:
-        breakdown["expected_improvement"] = SCORE_MIN
 
-    # ── 6. Confidence (0.05) ──────────────────────────────────────
-    confidence = _safe_get(payload, "confidence", None)
-    conf_score = _score_confidence(confidence)
-    score     += conf_score
+    # 6. Confidence (0.05)
+    conf_score = _score_confidence(_safe_get(payload, "confidence", None))
     breakdown["confidence"] = _clamp(conf_score)
+    score += conf_score
 
     final_score = _clamp(score)
-    feedback    = " ".join(feedback_parts) if feedback_parts else "Performance issue not identified."
+    feedback    = " ".join(feedback_parts) or "Performance issue not identified."
     return final_score, breakdown, feedback
 
 
@@ -408,11 +423,10 @@ def grade_hard(action: Action, ground_truth: dict) -> tuple[float, dict, str]:
 #  MAIN GRADER DISPATCHER
 # ─────────────────────────────────────────────
 
-def grade(action: Action, task_id: str) -> tuple[float, dict, str]:
+def grade(action: Action, task_id: str) -> tuple:
     """
-    Main grader entry point.
-    Looks up ground truth, dispatches to correct grader by difficulty.
-    ALWAYS returns (float, dict, str) — never crashes.
+    Main entry point.  Always returns (float, dict, str) — never crashes.
+    The returned float is always strictly inside (0, 1).
     """
     if action is None:
         return SCORE_MIN, {"error": "null_action"}, "No action provided."
@@ -425,12 +439,24 @@ def grade(action: Action, task_id: str) -> tuple[float, dict, str]:
 
     try:
         if difficulty == "easy":
-            return grade_easy(action, ground_truth)
+            result = grade_easy(action, ground_truth)
         elif difficulty == "medium":
-            return grade_medium(action, ground_truth)
+            result = grade_medium(action, ground_truth)
         elif difficulty == "hard":
-            return grade_hard(action, ground_truth)
+            result = grade_hard(action, ground_truth)
         else:
-            return SCORE_MIN, {"error": "unknown_difficulty"}, f"Unknown difficulty: {difficulty}"
+            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
+
     except Exception as e:
-        return SCORE_MIN, {"error": str(e)}, f"Grader error: {str(e)}"
+        return SCORE_MIN, {"error": str(e)}, f"Grader error: {str(e)}"