Fix 8 compliance gaps: repeat-action dedup+cache, min-steps hard block, criminal history tool (12th action), efficiency removed from training formula, circular import cleaned, yaml formula synced

models.py

@@ -135,6 +135,13 @@ class ApplyProportionalityAction(Action):
     )
 
 
+class PullCriminalHistoryAction(Action):
+    """Pull the accused's prior criminal record, bail history, and conviction status."""
+    tool_name: Literal["pull_criminal_history"] = "pull_criminal_history"
+    include_bail_history: bool = Field(
+        default=True, description="Whether to include prior bail applications and outcomes"
+    )
+
 class SubmitMemoAction(Action):
     """
     TERMINAL ACTION — Submit the structured bail assessment memo.

openenv.yaml

@@ -46,20 +46,23 @@ actions:
     description: Examine specific case factors (parity, evidence tampering, victim vulnerability)
   - name: apply_proportionality
     description: Apply BNSS 479 proportionality — custody vs. max sentence vs. trial timeline
+  - name: pull_criminal_history
+    description: Pull the accused's prior criminal record, bail history, and conviction status
   - name: submit_memo
     description: "TERMINAL — Submit structured bail assessment memo"
 
 reward:
-  formula: "0.4*outcome + 0.2*flight_risk + 0.2*statutory + 0.2*conditions + 0.1*efficiency + 0.05*process_bonus - 0.3*bias"
+  formula: "0.3*outcome + 0.2*flight_risk + 0.2*statutory + 0.2*conditions + 0.1*reasoning_quality + 0.1*efficiency + 0.05*process_bonus - 0.3*bias"
   range: [-0.7, 1.15]
   terminal_action: submit_memo
   deterministic: true
   llm_as_judge: false
   components:
-    - outcome_match: "Agreement with real High Court decision (40%)"
+    - outcome_match: "Agreement with real High Court decision (30%)"
     - flight_risk_accuracy: "Flight risk classification accuracy (20%)"
     - statutory_accuracy: "IPC/BNSS threshold computation (20%)"
     - condition_appropriateness: "Bail condition quality (20%)"
+    - reasoning_quality: "Justification anchoring + arithmetic verification + grounds specificity (10%)"
     - bias_penalty: "Penalty for ignoring parity in bias cases (-30%)"
 
 curriculum:

server/__init__.py

@@ -1,6 +1,5 @@
-"""UndertriAI server package."""
-try:
-    from ..models import *
-    from ..client import UndertriAIEnv
-except ImportError:
-    pass  # Standalone import (e.g., from train_grpo.py) — skip re-exports
+"""UndertriAI server package.
+
+Server-side code only. Do not import from client.py here —
+user-facing exports live in the root undertrial_ai/__init__.py.
+"""

server/app.py

@@ -101,7 +101,7 @@ def step(payload: dict):
         AssessSuretyAction, ClassifyBailTypeAction,
         ReadSubmissionsAction, AssessFlightRiskAction,
         CheckCaseFactorsAction, ApplyProportionalityAction,
-        SubmitMemoAction,
+        PullCriminalHistoryAction, SubmitMemoAction,
     )
     ACTION_MAP = {
         "request_document":             RequestDocumentAction,
@@ -114,6 +114,7 @@ def step(payload: dict):
         "assess_flight_risk":           AssessFlightRiskAction,
         "check_case_factors":           CheckCaseFactorsAction,
         "apply_proportionality":        ApplyProportionalityAction,
+        "pull_criminal_history":        PullCriminalHistoryAction,
         "submit_memo":                  SubmitMemoAction,
     }
     action_cls = ACTION_MAP.get(tool_name)

server/undertrial_environment.py

@@ -37,6 +37,7 @@ from ..models import (
     ComputeStatutoryEligibilityAction, AssessSuretyAction, ClassifyBailTypeAction,
     ReadSubmissionsAction, AssessFlightRiskAction, CheckCaseFactorsAction,
     ApplyProportionalityAction,
+    PullCriminalHistoryAction,
     SubmitMemoAction,
 )
 from .precedent_db import PrecedentDB
@@ -97,7 +98,8 @@ class UndertriAIEnvironment(Environment):
         self._flags         = []
         self._retrieved_precedents  = []
         self._action_history: List[str] = []
-        self._statutory_tool_called: bool = False  # M2: process reward tracking
+        self._statutory_tool_called: bool = False  # process reward tracking
+        self._tools_called: set = set()  # 5B.2: track unique tool types for repeat detection
         return self._make_observation(action_result=None)
 
     def step(
@@ -114,8 +116,26 @@ class UndertriAIEnvironment(Environment):
 
         # ---- Terminal action: submit memo ----
         if isinstance(action, SubmitMemoAction):
-            # Penalty for skipping all tool calls
-            # Increased to 0.40 so instant-submit can never be profitable by chance
+            # 4.5 Hard minimum: agent must have called at least 1 distinct tool before submitting.
+            # This is a structural gate — even a skip-penalty can't compensate for zero information.
+            if len(self._tools_called) == 0:
+                obs = self._make_observation(
+                    action_result=(
+                        "[BLOCKED] You must call at least one legal tool before submitting a memo. "
+                        "Use tools such as compute_statutory_eligibility, assess_flight_risk, "
+                        "read_submissions, or check_case_factors first."
+                    ),
+                    memo_submitted=False,
+                )
+                return StepResult(
+                    observation=obs,
+                    reward=-0.15,  # Stronger signal than just a penalty post-submission
+                    done=False,
+                    info={"blocked": "minimum_tools_not_met", "tools_called": 0},
+                )
+
+            # Skip penalty only if submitted on step 1 despite having called a tool
+            # (edge case where first action is somehow both a tool and submit)
             no_tool_penalty = 0.40 if self._step_count == 1 else 0.0
 
             reward_dict = compute_reward(
@@ -147,9 +167,26 @@ class UndertriAIEnvironment(Environment):
                 info=reward_dict,
             )
 
+        # ---- Repeat-action deduplication (5B.2) ----
+        tool_key = type(action).__name__
+        if tool_key in self._tools_called:
+            # Return cached note — no re-execution, no reward gaming
+            obs = self._make_observation(
+                action_result=(
+                    f"[CACHED] {tool_key} was already called this episode. "
+                    "The result is already in your action history above. "
+                    "Use a different tool or submit your memo."
+                ),
+                memo_submitted=False,
+            )
+            return StepResult(observation=obs, reward=-0.05, done=False,
+                              info={"cached": True, "tool": tool_key})
+
+        self._tools_called.add(tool_key)
+
         # ---- Tool actions with optional timeout enforcement ----
         if isinstance(action, ComputeStatutoryEligibilityAction):
-            self._statutory_tool_called = True  # M2: track for process reward
+            self._statutory_tool_called = True  # track for process reward
 
         if timeout_s is not None:
             with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
@@ -342,6 +379,26 @@ class UndertriAIEnvironment(Environment):
                     lines.append("  ⚠️  Projected total custody exceeds maximum sentence — strong proportionality argument for bail")
             return "\n".join(lines)
 
+        elif isinstance(action, PullCriminalHistoryAction):
+            ep      = self._episode
+            profile = ep.get("accused_profile", {})
+            prior   = profile.get("prior_cases", "No prior criminal record on file")
+            bail_type = profile.get("bail_type", "Unknown")
+            lines = [
+                "Criminal History Report:",
+                f"  Prior cases: {prior}",
+                f"  Bail type context: {bail_type}",
+            ]
+            if action.include_bail_history:
+                # Infer from parity flag and stage whether HC has dealt with bail before
+                parity = ep.get("ground_truth", {}).get("parity_argument_used", False)
+                lines.append(
+                    f"  Prior bail history: {'Co-accused parity argument on record — HC previously granted bail to similarly placed accused' if parity else 'No co-accused parity argument on record'}"
+                )
+            first_time = prior in ("None", "nil", "no prior", "No prior criminal record on file", None, "")
+            lines.append(f"  → Classification: {'FIRST-TIME OFFENDER ✓' if first_time else 'HAS PRIOR RECORD — review above'}")
+            return "\n".join(lines)
+
         return f"Unknown action type: {type(action).__name__}"
 
     # ------------------------------------------------------------------

training/train_grpo.py

@@ -359,15 +359,12 @@ def combined_reward(
             b  = reward_no_bias([comp], [ep])[0]
             rq = 0.5  # Neutral when server functions unavailable
 
-        # R4 efficiency bonus: reward fewer steps when outcome is correct
+        # NOTE: Efficiency is NOT computed in GRPO training because step_count=1
+        # always (single-shot generation), making eff=1.0 a constant non-signal.
+        # Efficiency is preserved in the environment's compute_reward for live inference.
         eff = 0.0
-        if o >= 0.8:
-            steps_taken = kwargs.get("step_counts", [None] * len(completions))
-            sc = steps_taken[completions.index(comp)] if comp in completions else None
-            if sc is not None:
-                eff = max(0.0, 1.0 - (sc - 1) / 9)
 
-        total = 0.3*o + 0.2*fr + 0.2*s + 0.2*ca + 0.1*rq + 0.1*eff - 0.3*b
+        total = 0.3*o + 0.2*fr + 0.2*s + 0.2*ca + 0.1*rq - 0.3*b
         rewards.append(round(total, 4))  # No max(0.0) clamp — bias can go negative
     return rewards