added the run_episode function

graders/grader_classification.py

@@ -13,31 +13,27 @@ class MediumClassificationGrader:
     def __init__(self) -> None:
         self.last_breakdown: dict[str, Any] = {}
 
-    def grade(self, state: Any, ground_truth: dict[str, Any] | None = None) -> float:
+    def grade(self, state: Any = None, ground_truth: dict[str, Any] | None = None) -> float:
+        if state is None:
+            self.last_breakdown = {"error": "empty_state_ping", "score": 0.1}
+            return 0.1
+
         tp = float(getattr(state, "total_tp", 0))
         tn = float(getattr(state, "total_tn", 0))
         fp = float(getattr(state, "total_fp", 0))
         fn = float(getattr(state, "total_fn", 0))
 
-        total = tp + tn + fp + fn
-        
-        # The maximum possible score if they made zero mistakes
         actual_anomalies = tp + fn
         actual_valid = tn + fp
-        
         perfect_signal = (actual_anomalies * _TP_WEIGHT) + (actual_valid * _TN_WEIGHT)
-        
+
         if perfect_signal == 0:
             return 0.1
 
         positive_signal = (tp * _TP_WEIGHT) + (tn * _TN_WEIGHT)
         negative_signal = (fp * _FP_PENALTY) + (fn * _FN_PENALTY)
 
-        # Normalize against the true perfect scenario
         raw_score = max(0.0, positive_signal - negative_signal) / perfect_signal
-
-        # Strict hackathon boundary
         score = max(0.1, min(0.99, raw_score))
-        
         self.last_breakdown = {"tp": int(tp), "tn": int(tn), "fp": int(fp), "fn": int(fn), "score": score}
         return score

graders/grader_detection.py

@@ -13,30 +13,27 @@ class EasyDetectionGrader:
     def __init__(self) -> None:
         self.last_breakdown: dict[str, Any] = {}
 
-    def grade(self, state: Any, ground_truth: dict[str, Any] | None = None) -> float:
+    def grade(self, state: Any = None, ground_truth: dict[str, Any] | None = None) -> float:
+        if state is None:
+            self.last_breakdown = {"error": "empty_state_ping", "score": 0.1}
+            return 0.1
+
         tp = float(getattr(state, "total_tp", 0))
         tn = float(getattr(state, "total_tn", 0))
         fp = float(getattr(state, "total_fp", 0))
         fn = float(getattr(state, "total_fn", 0))
 
-        total = tp + tn + fp + fn
-                
-        # The maximum possible score if they made zero mistakes
         actual_anomalies = tp + fn
         actual_valid = tn + fp
-        
         perfect_signal = (actual_anomalies * _TP_WEIGHT) + (actual_valid * _TN_WEIGHT)
-        
+
         if perfect_signal == 0:
             return 0.1
 
         positive_signal = (tp * _TP_WEIGHT) + (tn * _TN_WEIGHT)
         negative_signal = (fp * _FP_PENALTY) + (fn * _FN_PENALTY)
 
-        # Normalize against the true perfect scenario
         raw_score = max(0.0, positive_signal - negative_signal) / perfect_signal
-
-        # Strict hackathon boundary
         score = max(0.1, min(0.99, raw_score))
         self.last_breakdown = {"tp": int(tp), "tn": int(tn), "fp": int(fp), "fn": int(fn), "score": score}
         return score

graders/grader_fix.py

@@ -13,30 +13,27 @@ class HardFixGrader:
     def __init__(self) -> None:
         self.last_breakdown: dict[str, Any] = {}
 
-    def grade(self, state: Any, ground_truth: dict[str, Any] | None = None) -> float:
+    def grade(self, state: Any = None, ground_truth: dict[str, Any] | None = None) -> float:
+        if state is None:
+            self.last_breakdown = {"error": "empty_state_ping", "score": 0.1}
+            return 0.1
+
         tp = float(getattr(state, "total_tp", 0))
         tn = float(getattr(state, "total_tn", 0))
         fp = float(getattr(state, "total_fp", 0))
         fn = float(getattr(state, "total_fn", 0))
 
-        total = tp + tn + fp + fn
-                
-        # The maximum possible score if they made zero mistakes
         actual_anomalies = tp + fn
         actual_valid = tn + fp
-        
         perfect_signal = (actual_anomalies * _TP_WEIGHT) + (actual_valid * _TN_WEIGHT)
-        
+
         if perfect_signal == 0:
             return 0.1
 
         positive_signal = (tp * _TP_WEIGHT) + (tn * _TN_WEIGHT)
         negative_signal = (fp * _FP_PENALTY) + (fn * _FN_PENALTY)
 
-        # Normalize against the true perfect scenario
         raw_score = max(0.0, positive_signal - negative_signal) / perfect_signal
-
-        # Strict hackathon boundary
         score = max(0.1, min(0.99, raw_score))
         self.last_breakdown = {"tp": int(tp), "tn": int(tn), "fp": int(fp), "fn": int(fn), "score": score}
         return score

inference.py

@@ -190,7 +190,7 @@ def run_inference() -> None:
                 action = AuditorAction(decisions=decisions)
 
             obs = env.step(action)
-            step_reward = float(obs.reward) if obs.reward is not None else 0.00
+            step_reward = float(obs.reward) if obs.reward is not None else 0.1
             all_rewards.append(step_reward)
             steps_completed = step_num
 
@@ -213,13 +213,13 @@ def run_inference() -> None:
     finally:
         # 4. The Ultimate Safety Clamp
         if not all_rewards:
-            all_rewards = [0.00]
+            all_rewards = [0.1]
             
         current_sum = sum(all_rewards)
         
-        if current_sum <= 0.0:
-            # If the script crashed or agent scored 0.0, inject absolute minimum
-            all_rewards[-1] = 0.01
+        if current_sum <= 0.1:
+            # If the script crashed or agent scored nothing, inject the grader floor
+            all_rewards[-1] = 0.1
         elif current_sum >= 1.0:
             # If floating point math drifted to 1.0+, force the final entry down
             excess = current_sum - 0.99

server/fin_auditor_environment.py

@@ -137,7 +137,7 @@ class FinAuditorEnvironment(Environment):
         return FinAuditorObservation(
             features=anomalies,
             message=f"Fin Auditor engine ready. {len(anomalies)} trades loaded.",
-            reward=0.0,
+            reward=0.1,
             done=False
         )
 

tasks/task1_easy.py

@@ -33,4 +33,40 @@ def setup_env(env) -> None:
             env.difficulty = hft_auditor.Difficulty.EASY
             env._MAX_EPISODE_STEPS = MAX_STEPS
     except Exception as e:
-        print(f"[task_easy] Could not set difficulty: {e}")
+        print(f"[task_easy] Could not set difficulty: {e}")
+
+def run_episode(env, agent_fn) -> dict:
+    """Run a single EASY anomaly-detection episode and return the graded result.
+
+    Called by the OpenEnv evaluator. agent_fn receives an observation and
+    returns a list of binary decisions (0 = valid, 1 = anomaly).
+    """
+    setup_env(env)
+    total_reward = 0.0
+    steps_done = 0
+
+    try:
+        obs = env.reset()
+        for _ in range(MAX_STEPS):
+            decisions = agent_fn(obs)
+            from models import AuditorAction
+            action = AuditorAction(decisions=decisions)
+            obs = env.step(action)
+            total_reward += float(obs.reward) if obs.reward is not None else 0.0
+            steps_done += 1
+            if obs.done:
+                break
+    except Exception as exc:
+        print(f"[task_easy] run_episode error at step {steps_done}: {exc}")
+
+    # Always grade — even partial data yields a valid score via perfect_signal fallback
+    final_score = grader.grade(env.state)
+
+    return {
+        "task": TASK_ID,
+        "difficulty": DIFFICULTY,
+        "steps": steps_done,
+        "total_reward": round(total_reward, 4),
+        "score": round(final_score, 4),
+        "grader_breakdown": grader.last_breakdown,
+    }

tasks/task2_medium.py

@@ -33,4 +33,41 @@ def setup_env(env) -> None:
             env.difficulty = hft_auditor.Difficulty.MEDIUM
             env._MAX_EPISODE_STEPS = MAX_STEPS
     except Exception as e:
-        print(f"[task_medium] Could not set difficulty: {e}")
+        print(f"[task_medium] Could not set difficulty: {e}")
+
+
+def run_episode(env, agent_fn) -> dict:
+    """Run a single MEDIUM anomaly-detection episode and return the graded result.
+
+    Called by the OpenEnv evaluator. agent_fn receives an observation and
+    returns a list of binary decisions (0 = valid, 1 = anomaly).
+    """
+    setup_env(env)
+    total_reward = 0.0
+    steps_done = 0
+
+    try:
+        obs = env.reset()
+        for _ in range(MAX_STEPS):
+            decisions = agent_fn(obs)
+            from models import AuditorAction
+            action = AuditorAction(decisions=decisions)
+            obs = env.step(action)
+            total_reward += float(obs.reward) if obs.reward is not None else 0.0
+            steps_done += 1
+            if obs.done:
+                break
+    except Exception as exc:
+        print(f"[task_medium] run_episode error at step {steps_done}: {exc}")
+
+    # Always grade — even partial data yields a valid score via perfect_signal fallback
+    final_score = grader.grade(env.state)
+
+    return {
+        "task": TASK_ID,
+        "difficulty": DIFFICULTY,
+        "steps": steps_done,
+        "total_reward": round(total_reward, 4),
+        "score": round(final_score, 4),
+        "grader_breakdown": grader.last_breakdown,
+    }

tasks/task3_hard.py

@@ -33,4 +33,41 @@ def setup_env(env) -> None:
             env.difficulty = hft_auditor.Difficulty.HARD
             env._MAX_EPISODE_STEPS = MAX_STEPS
     except Exception as e:
-        print(f"[task_hard] Could not set difficulty: {e}")
+        print(f"[task_hard] Could not set difficulty: {e}")
+
+
+def run_episode(env, agent_fn) -> dict:
+    """Run a single HARD anomaly-detection episode and return the graded result.
+
+    Called by the OpenEnv evaluator. agent_fn receives an observation and
+    returns a list of binary decisions (0 = valid, 1 = anomaly).
+    """
+    setup_env(env)
+    total_reward = 0.0
+    steps_done = 0
+
+    try:
+        obs = env.reset()
+        for _ in range(MAX_STEPS):
+            decisions = agent_fn(obs)
+            from models import AuditorAction
+            action = AuditorAction(decisions=decisions)
+            obs = env.step(action)
+            total_reward += float(obs.reward) if obs.reward is not None else 0.0
+            steps_done += 1
+            if obs.done:
+                break
+    except Exception as exc:
+        print(f"[task_hard] run_episode error at step {steps_done}: {exc}")
+
+    # Always grade — even partial data yields a valid score via perfect_signal fallback
+    final_score = grader.grade(env.state)
+
+    return {
+        "task": TASK_ID,
+        "difficulty": DIFFICULTY,
+        "steps": steps_done,
+        "total_reward": round(total_reward, 4),
+        "score": round(final_score, 4),
+        "grader_breakdown": grader.last_breakdown,
+    }