fix: pinned nanobind, disabled benchmark for docker, and isolated state endpoint

inference.py

@@ -1,19 +1,10 @@
 #!/usr/bin/env python3
-# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-# inference.py — OpenEnv Evaluation Script (Hackathon Submission)
-#
-# STDOUT FORMAT (strict regex compliance):
-#   [START] task=<task_name> env=<benchmark> model=<model_name>
-#   [STEP] step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
-#   [END] success=<true|false> steps=<n> rewards=<r1,r2,...,rn>
-#
-# ALL debug output goes to stderr. NO JSON on stdout. NO extra whitespace.
-# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 import os
 import sys
 import json
 import re
+import datetime
 import traceback
 import time
 from typing import List
@@ -36,10 +27,6 @@ except ImportError:
 
 from models import AuditorAction
 
-# ── Debug logger: ONLY to stderr ─────────────────────────────────────────────
-def _dbg(msg: str) -> None:
-    print(msg, file=sys.stderr, flush=True)
-
 class LLMResponse(BaseModel):
     reasoning: str
     decisions: List[int]
@@ -52,9 +39,7 @@ if not HF_TOKEN:
     raise ValueError("CRITICAL: HF_TOKEN environment variable is missing.")
 
 TASK_ID:      str = os.getenv("TASK_ID", "anomaly_detection_hard")
-ENV_NAME:     str = "fin_auditor"
 
-# FIX: Sync the inference max_steps default with the active task
 if "easy" in TASK_ID.lower():
     _DEFAULT_MAX = 5
 elif "medium" in TASK_ID.lower():
@@ -86,6 +71,9 @@ Example:
 {"reasoning": "Trade 1 has high risk. Trade 2 is safe.", "decisions": [1, 0, 1]}
 """
 
+def _ts() -> str:
+    return datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
 def _build_user_prompt(step: int, features: list[list[float]]) -> str:
     lines = [
         f"Step {step}: You have {len(features)} flagged trades to audit.",
@@ -165,10 +153,8 @@ def _call_llm(step: int, features: list[list[float]]) -> list[int]:
             content = response.choices[0].message.content or ""
             return _parse_llm_decisions(content, len(features))
         except Exception as e:
-            _dbg(f"[LLM RETRY {attempt+1}/{max_retries}] {e}")
             time.sleep(1)
 
-    _dbg("[LLM] All retries exhausted, using risk_score fallback")
     fallback_decisions = []
     for row in features:
         if len(row) >= 4:
@@ -179,59 +165,75 @@ def _call_llm(step: int, features: list[list[float]]) -> list[int]:
     return fallback_decisions
 
 def run_inference() -> None:
+    episode_id: str = "unknown"
+    total_reward: float = 0.0
     steps_completed: int = 0
-    all_rewards: list[float] = []
-    success: bool = False
-    error_msg: str | None = None
-
-    # ── [START] — always emitted ──────────────────────────────────────────
-    print(f"[START] task={TASK_ID} env={ENV_NAME} model={MODEL_NAME}", flush=True)
+    status: str = "SUCCESS"
 
     try:
         env = FinAuditorEnvironment()
         obs = env.reset()
+        episode_id = getattr(env.state, 'episode_id', "test_run")
 
-        _dbg(f"[DBG] Episode started. Features: {len(obs.features)} rows, difficulty: {TASK_ID}")
+        start_payload = {
+            "episode_id": episode_id, 
+            "model": MODEL_NAME, 
+            "difficulty": TASK_ID, 
+            "max_steps": MAX_STEPS
+        }
+        print(f"[START] {json.dumps(start_payload)}", flush=True)
 
         for step_num in range(1, MAX_STEPS + 1):
-            step_reward = 0.0
+            step_reward = 0.0  
             features = obs.features
 
             if not features:
                 action = AuditorAction(decisions=[])
-                _dbg(f"[DBG] Step {step_num}: Empty feature matrix")
+                _last_reasoning = "Empty matrix."
             else:
                 decisions = _call_llm(step_num, features)
                 action = AuditorAction(decisions=decisions)
 
             obs = env.step(action)
-            step_reward = obs.reward if obs.reward is not None else 0.0
-            all_rewards.append(step_reward)
+            # Apply safe floor fallback in inference just in case
+            step_reward = obs.reward if obs.reward is not None else 0.01 
+            total_reward += step_reward
             steps_completed = step_num
 
-            # ── [STEP] — plain text, 2 decimal places, lowercase bools ────
-            action_str = ",".join(str(d) for d in action.decisions) if action.decisions else "none"
-            done_str = "true" if obs.done else "false"
-            print(f"[STEP] step={step_num} action={action_str} reward={step_reward:.2f} done={done_str} error=null", flush=True)
-
-            _dbg(f"[DBG] Step {step_num}: reward={step_reward:.4f}, features={len(obs.features)}, done={obs.done}")
+            # FIX: Used round(..., 4) to prevent collapsing small fractions into 0.00
+            step_payload = {
+                "step": step_num,
+                "anomalies": len(features),
+                "reward": round(float(step_reward), 4),
+                "cumulative_reward": round(float(total_reward), 4),
+                "done": bool(obs.done),
+                "error": None,
+                "reasoning": _last_reasoning[:120].replace('\n', ' ') + "...",
+                "tp": getattr(env.state, 'last_tp', 0),
+                "tn": getattr(env.state, 'last_tn', 0),
+                "fp": getattr(env.state, 'last_fp', 0),
+                "fn": getattr(env.state, 'last_fn', 0)
+            }
+            print(f"[STEP] {json.dumps(step_payload)}", flush=True)
 
             if obs.done:
                 break
 
-        success = True
-
     except KeyboardInterrupt:
-        error_msg = "interrupted"
-        _dbg("[DBG] Interrupted by user")
+        status = "INTERRUPTED"
     except Exception as exc:
-        error_msg = str(exc).replace("\n", " ")[:80]
-        _dbg(f"[ERROR] {traceback.format_exc()}")
-    finally:
-        # ── [END] — ALWAYS emitted, even on crash ────────────────────────
-        success_str = "true" if success else "false"
-        rewards_str = ",".join(f"{r:.2f}" for r in all_rewards) if all_rewards else "0.00"
-        print(f"[END] success={success_str} steps={steps_completed} rewards={rewards_str}", flush=True)
+        status = "ERROR"
+        traceback.print_exc(file=sys.stderr)
+
+    avg_reward = total_reward / max(steps_completed, 1)
+    
+    # FIX: Used round(..., 4) for terminal payload outputs as well
+    end_payload = {
+        "total_reward": round(float(total_reward), 4), 
+        "avg_reward": round(float(avg_reward), 4),
+        "status": status
+    }
+    print(f"[END] {json.dumps(end_payload)}", flush=True)
 
 if __name__ == "__main__":
     run_inference()

server/app.py

@@ -44,9 +44,6 @@ except ImportError as e:
 # PHASE 2: SYSTEM STATE & AUTHORITY TRACKING
 # ==============================================================================
 
-# FIX: Global pointer to capture the OpenEnv-managed instance
-active_env_instance = None
-
 if HAS_ENV and NATIVE_VERIFIED:
     class TrackedFinAuditorEnvironment(FinAuditorEnvironment):
         """Wrapper class to capture the environment instance created by OpenEnv"""
@@ -56,7 +53,8 @@ if HAS_ENV and NATIVE_VERIFIED:
             active_env_instance = self
             
     # OpenEnv creates the FastAPI app and instantiates TrackedFinAuditorEnvironment internally
-    app = create_app(TrackedFinAuditorEnvironment, AuditorAction, AuditorObservation)
+    active_env_instance = FinAuditorEnvironment()
+    app = create_app(lambda: active_env_instance, AuditorAction, AuditorObservation)
 else:
     app = FastAPI(title="PayGorn (MOCK MODE)")
     @app.post("/reset")

server/fin_auditor_environment.py

@@ -82,10 +82,8 @@ class FinAuditorEnvironment(Environment):
         self.engine = hft_auditor.ReconciliationEngine(self._RING_BUFFER_CAPACITY)
         self.sim_time_ns = 0
         
-        # 1. READ TASK_ID FROM ENVIRONMENT
         task_id = os.getenv("TASK_ID", "anomaly_detection_hard").lower()
         
-        # 2. MAP TO C++ DIFFICULTY ENUM & SYNC YAML STEPS
         if "easy" in task_id:
             self.difficulty = hft_auditor.Difficulty.EASY
             self._MAX_EPISODE_STEPS = 5
@@ -98,60 +96,42 @@ class FinAuditorEnvironment(Environment):
 
     def reset(self) -> AuditorObservation:
         self._state = State(episode_id=str(uuid4()), step_count=0)
-
-        # Re-initialize the engine for a clean episode
-        self.engine = hft_auditor.ReconciliationEngine(self._RING_BUFFER_CAPACITY)
-        self.sim_time_ns = 0
-
-        # Generate the first batch so step 1 has data to evaluate
-        self.engine.generate_batch(self.difficulty, self._INGEST_CHUNK_SIZE, self.sim_time_ns)
-
-        # Advance time past Δ_max to expire the batch
-        self.sim_time_ns += 6_000_000_000
+        self.sim_time_ns += self._DELTA_MAX_NS
         self.engine.tick(self.sim_time_ns)
 
-        # Get the anomaly matrix for the agent (features for step 1)
-        anomalies: list[list[float]] = self.engine.get_anomaly_matrix().tolist()
-
         return FinAuditorObservation(
-            features=anomalies,
-            message=f"Engine ready. {len(anomalies)} trades awaiting audit.",
-            reward=0.001 / self._MAX_EPISODE_STEPS,  # Safe fractional minimum
+            features=[],
+            message="Fin Auditor engine ready.",
+            reward=0.01,  # Safe minimum floor, not divided
             done=False
         )
 
     def step(self, action: AuditorAction) -> AuditorObservation:  # type: ignore[override]
         self._state.step_count += 1
 
-        # 1. REWARD CALCULATION & MATHEMATICAL NORMALIZATION
-        step_reward = 0.0
+        # FIX: OpenEnv grader:reward evaluates EACH step's reward independently.
+        # Must be strictly in (0.01, 0.99) for every step, no exceptions.
         if action and action.decisions:
             action_array = np.array(action.decisions, dtype=np.uint8)
             raw_reward = float(self.engine.compute_reward(action_array))
-            
-            # Map raw reward bounds [-4.0, 40.0] to a [0, 1] percentage
+            # Map raw bounds [-4.0, 40.0] -> [0.0, 1.0]
             normalized_raw = (raw_reward + 4.0) / 44.0
-            
-            # Clamp to prevent EXACT 0.0 or 1.0 boundary hits
-            safe_clamped = max(0.01, min(0.99, normalized_raw))
-            
-            # Distribute over episode length so the SUM is strictly in (0, 1)
-            step_reward = safe_clamped / self._MAX_EPISODE_STEPS
-
-        # 2. GENERATE NEW DATA (Using procedural C++ engine)
+            # Clamp strictly inside (0.01, 0.999)
+            step_reward = max(0.01, min(0.99, normalized_raw))
+        else:
+            # Empty decisions (no-op step) - return safe floor, NOT 0.0
+            step_reward = 0.01
+
         self.engine.generate_batch(self.difficulty, self._INGEST_CHUNK_SIZE, self.sim_time_ns)
         
-        # 3. ADVANCE TIME & EXPIRE
         self.sim_time_ns += 6_000_000_000
         self.engine.tick(self.sim_time_ns)
 
-        # 4. EXTRACT NEW MATRIX
         anomalies: list[list[float]] = self.engine.get_anomaly_matrix().tolist()
         total_anomalies = len(anomalies)
 
         done = self._state.step_count >= self._MAX_EPISODE_STEPS
 
-        # Expose C++ tracking metrics to the Python state
         self._state.last_tp = self.engine.last_tp
         self._state.last_tn = self.engine.last_tn
         self._state.last_fp = self.engine.last_fp