10/4/2026

app.py

@@ -47,11 +47,11 @@ MAX_SESSIONS = 100
 # Global metrics tracking (shared)
 GLOBAL_METRICS = {
     "total_episodes": 0,
-    "success_rate": 0.0,
+    "success_rate": 0.01,
     "total_successful": 0,
-    "avg_easy_score": 0.0,
-    "avg_medium_score": 0.0,
-    "avg_hard_score": 0.0,
+    "avg_easy_score": 0.01,
+    "avg_medium_score": 0.01,
+    "avg_hard_score": 0.01,
     "scores_by_difficulty": {"easy": [], "medium": [], "hard": []}
 }
 

app_SuEnv.py

@@ -36,11 +36,11 @@ active_sessions: Dict[str, SupportEnvironment] = {}
 episode_history: List[Dict[str, Any]] = []
 GLOBAL_METRICS = {
     "total_episodes": 0,
-    "success_rate": 0.0,
+    "success_rate": 0.01,
     "total_successful": 0,
-    "avg_easy_score": 0.0,
-    "avg_medium_score": 0.0,
-    "avg_hard_score": 0.0,
+    "avg_easy_score": 0.01,
+    "avg_medium_score": 0.01,
+    "avg_hard_score": 0.01,
     "scores_by_difficulty": {"easy": [], "medium": [], "hard": []}
 }
 

inference.py

@@ -156,7 +156,7 @@ def main() -> None:
         rewards: List[float] = []
         steps_taken = 0
         success = False
-        final_score = 0.0
+        final_score = 0.01
         
         try:
             with env.sync() as conn:
@@ -212,7 +212,7 @@ def main() -> None:
                     grade_resp = requests.post(grader_url, json={"session_id": session_id}, timeout=30)
                     if grade_resp.status_code == 200:
                         grade_data = grade_resp.json()
-                        final_score = float(grade_data.get('score', 0.0))
+                        final_score = float(grade_data.get('score', 0.01))
                         success = bool(grade_data.get('passed', False))
                 except Exception:
                     pass
@@ -220,7 +220,7 @@ def main() -> None:
                 log_end(success=success, steps=steps_taken, score=final_score, rewards=rewards)
                     
         except Exception as e:
-            log_end(success=False, steps=steps_taken, score=0.0, rewards=rewards)
+            log_end(success=False, steps=steps_taken, score=0.01, rewards=rewards)
 
 if __name__ == "__main__":
     main()

models.py

@@ -90,13 +90,13 @@ class SupportState(State):
 
     # Performance tracking
     classification_correct: bool = False
-    response_quality_score: float = 0.0
+    response_quality_score: float = 0.01
     escalation_correct: bool = False
     resolved: bool = False
 
     # Cumulative metrics
-    total_reward: float = 0.0
-    customer_sentiment: float = 0.0
+    total_reward: float = 0.01
+    customer_sentiment: float = 0.01
 
 
 class PublicSupportState(State):
@@ -111,10 +111,10 @@ class PublicSupportState(State):
 
     # Performance tracking
     classification_correct: bool = False
-    response_quality_score: float = 0.0
+    response_quality_score: float = 0.01
     escalation_correct: bool = False
     resolved: bool = False
 
     # Cumulative metrics
-    total_reward: float = 0.0
-    customer_sentiment: float = 0.0
+    total_reward: float = 0.01
+    customer_sentiment: float = 0.01

server/app.py

@@ -56,11 +56,11 @@ SESSION_TTL_SECONDS = 3600
 # Global metrics tracking
 METRICS = {
     "total_episodes": 0,
-    "success_rate": 0.0,
+    "success_rate": 0.01,
     "total_successful": 0,
-    "avg_easy_score": 0.0,
-    "avg_medium_score": 0.0,
-    "avg_hard_score": 0.0,
+    "avg_easy_score": 0.01,
+    "avg_medium_score": 0.01,
+    "avg_hard_score": 0.01,
     "scores_by_difficulty": {"easy": [], "medium": [], "hard": []}
 }
 

server/environment.py

@@ -107,10 +107,10 @@ class SupportEnvironment(Environment):
             task_difficulty=difficulty,
             max_steps=max_steps,
             classification_correct=False,
-            response_quality_score=0.0,
+            response_quality_score=0.01,
             escalation_correct=False,
             resolved=False,
-            total_reward=0.0
+            total_reward=0.01
         )
         
         # Reset episode flags

server/graders.py

@@ -116,8 +116,9 @@ class SupportGrader:
         total_score += ordering_penalty
         
         # Ensure score is strictly within (0, 1) range per validation rules
-        # Clipping to [0.0001, 0.9999] ensures we never return exactly 0.0 or 1.0
-        total_score = max(0.0001, min(0.9999, total_score))
+        # We round and then clamp to [0.01, 0.99] to guarantee it never hits 0.0 or 1.0
+        total_score = round(total_score, 4)
+        total_score = max(0.01, min(0.99, total_score))
         
         # Generate feedback
         feedback = self._generate_feedback(breakdown, task_difficulty)
@@ -126,8 +127,8 @@ class SupportGrader:
         passed = total_score >= 0.6
         
         return GradeResult(
-            score=round(total_score, 4),
-            breakdown={k: round(max(0.0001, min(0.9999, v)), 4) for k, v in breakdown.items()},
+            score=total_score,
+            breakdown={k: max(0.01, min(0.99, round(v, 4))) for k, v in breakdown.items()},
             feedback=feedback,
             passed=passed
         )
@@ -146,7 +147,7 @@ class SupportGrader:
         if idx_resolve_or_escalate != -1:
             if idx_classify == -1 or idx_resolve_or_escalate < idx_classify:
                 return -0.25 # Penalty
-        return 0.0
+        return 0.01
     
     def _grade_classification(
         self, 
@@ -159,14 +160,14 @@ class SupportGrader:
         ]
         
         if not classifications:
-            return 0.0  # No classification attempted
+            return 0.01  # No classification attempted
         
         # Check first classification (most important)
         first_class = classifications[0].get("content", "").lower().strip()
         target_clean = target.lower().strip()
         
         if first_class == target_clean:
-            return 1.0
+            return 0.99
         
         # Partial credit for related categories
         category_relations = {
@@ -186,7 +187,7 @@ class SupportGrader:
             if cls.get("content", "").lower().strip() == target_clean:
                 return 0.5  # Corrected but not first try
         
-        return 0.2  # Wrong classification
+        return 0.21  # Wrong classification
     
     def _grade_responses(
         self,
@@ -200,7 +201,7 @@ class SupportGrader:
         ]
 
         if not responses:
-            return 0.0
+            return 0.01
 
         total_score = 0.0
 
@@ -227,7 +228,7 @@ class SupportGrader:
 
             # Response length check
             word_count = len(content.split())
-            length_score = min(1.0, word_count / 20)  # At least 20 words ideal
+            length_score = min(0.99, word_count / 20)  # At least 20 words ideal
 
             # ANTI-GAMING: Detect keyword stuffing
             # Stuffing = many keywords in short text (high density), not just many keywords
@@ -264,7 +265,7 @@ class SupportGrader:
                 # If confidence is < 0.5, it's a weak response
                 resp_score *= (0.5 + 0.5 * confidence)
 
-            total_score += max(0.0, min(1.0, resp_score))
+            total_score += max(0.01, min(0.99, resp_score))
 
         # Average across responses
         avg_score = total_score / len(responses)
@@ -283,7 +284,7 @@ class SupportGrader:
         #   easy   → no adjustment
         #   medium → scores below 0.6 are compressed (×0.85 multiplier)
         #   hard   → scores below 0.7 are compressed (×0.75 multiplier)
-        # A perfect raw score still maps to 1.0 at every difficulty.
+        # A perfect raw score still maps to 0.99 at every difficulty.
         if difficulty == "hard":
             if avg_score < 0.7:
                 avg_score *= 0.75          # weak response on a hard task
@@ -292,7 +293,7 @@ class SupportGrader:
             if avg_score < 0.6:
                 avg_score *= 0.85          # weak response on a medium task
 
-        return max(0.0, min(1.0, avg_score))
+        return max(0.01, min(0.99, avg_score))
     
     def _grade_escalation(
         self,
@@ -333,18 +334,18 @@ class SupportGrader:
             # Check reason quality
             reason = escalations[0].get("content", "")
             if len(reason.split()) >= 10 and any(kw in reason.lower() for kw in ["immediate", "severity", "sensitivity", "human"]):
-                return 1.0
+                return 0.99
             elif len(reason.split()) >= 5:
                 return 0.9
             return 0.7  # Right decision but poor explanation
 
         elif not should_escalate and not escalated:
             # Correct: did not escalate when not needed
-            return 1.0
+            return 0.99
 
         elif should_escalate and not escalated:
             # Wrong: should have escalated but didn't
-            return 0.0  # Harsher penalty for missing required escalation
+            return 0.01  # Harsher penalty for missing required escalation
 
         else:
             # Wrong: escalated when not needed (unnecessary escalation)
@@ -408,12 +409,12 @@ class SupportGrader:
         base_score = overlap_ratio * 0.7
         action_bonus = 0.3 if has_action_word else 0.0
 
-        return min(1.0, base_score + action_bonus)
+        return min(0.99, base_score + action_bonus)
     
     def _grade_efficiency(self, steps: int, max_steps: int, difficulty: str = "easy") -> float:
         """Grade step efficiency. Harder tasks require more deliberation."""
         if steps <= 1:
-            return 1.0 if difficulty == "easy" else 0.5 # Discourage one-step solutions for complex tasks
+            return 0.99 if difficulty == "easy" else 0.5 # Discourage one-step solutions for complex tasks
         
         # Stricter for hard: optimal path is usually 4-6 steps
         if difficulty == "hard":
@@ -421,12 +422,12 @@ class SupportGrader:
             if steps < 5:
                 return 0.4 # Superficial handling
             if steps <= 9:
-                return 1.0 # High quality deliberation
+                return 0.99 # High quality deliberation
             # Penalize the tail end for inefficiency
             return round(max(0.3, 1.0 - 0.8 * ((steps - 9) / (max_steps - 9))), 2)
             
         # Standard linear for easy/medium
-        return round(1.0 - 0.8 * ((steps - 1) / (max_steps - 1)), 2)
+        return round(0.99 - 0.8 * ((steps - 1) / (max_steps - 1)), 2)
     
     def _get_weights(self, difficulty: str) -> Dict[str, float]:
         """Get grading weights based on difficulty."""

server/semantic_scorer.py

@@ -45,14 +45,14 @@ class SemanticScorer:
         Returns a dict with empathy, solution, and resolution alignment scores.
         """
         if not responses or not expected_resolution:
-            return {"empathy": 0.0, "solution": 0.0, "resolution": 0.0, "overall": 0.0}
+            return {"empathy": 0.01, "solution": 0.01, "resolution": 0.01, "overall": 0.01}
 
         if self.model is None:
             return None
 
         combined_response = " ".join([r for r in responses if len(r) > 10])
         if not combined_response:
-            return {"empathy": 0.0, "solution": 0.0, "resolution": 0.0, "overall": 0.0}
+            return {"empathy": 0.01, "solution": 0.01, "resolution": 0.01, "overall": 0.01}
 
         try:
             from sklearn.metrics.pairwise import cosine_similarity
@@ -73,11 +73,11 @@ class SemanticScorer:
             
             # Non-linear scaling: 0.2 similarity is baseline, 0.9 similarity is perfect.
             def scale(sim):
-                return min(0.9999, max(0.0001, (sim - 0.1) / 0.7))
+                return min(0.99, max(0.01, (sim - 0.1) / 0.7))
 
             empathy_score = scale(sim_empathy)
             solution_score = scale(sim_solution)
-            resolution_score = max(0.0001, min(0.9999, (sim_resolution - 0.2) / 0.7))
+            resolution_score = max(0.01, min(0.99, (sim_resolution - 0.2) / 0.7))
 
             overall = (empathy_score * 0.2) + (solution_score * 0.2) + (resolution_score * 0.6)