refactor: Update grading logic and submission handling across tasks for improved accuracy and consistency

inference.py

@@ -258,7 +258,7 @@ def _run_t1_episode(env: Task1Environment, seed: int, ep_num: int) -> Dict[str,
 
             if done:
                 v = r_val
-                grader_score = 1.0 if v >= 4.9 else (0.5 if v >= 0.9 else 0.0)
+                grader_score = 0.999 if v >= 4.9 else (0.5 if v >= 0.9 else 0.0)
                 break
 
             if not is_last:
@@ -441,7 +441,7 @@ def _run_t3_episode(env: Task3Environment, seed: int, ep_num: int) -> Dict[str,
 
             if done:
                 v = r_val
-                grader_score = 1.0 if v >= 4.9 else (0.3 if v >= 1.0 else 0.0)
+                grader_score = 0.999 if v >= 4.9 else (0.3 if v >= 0.999 else 0.0)
                 break
 
             if not is_last:

server/tasks/task1/actions.py

@@ -117,38 +117,62 @@ def get_call_graph(ctx: Any, qkey: str, params: Dict) -> Tuple[str, Reward]:
     )
 
 
-def submit(ctx: Any, qkey: str, params: Dict) -> Tuple[str, Reward]:
-    """Handle SUBMIT action."""
-    fn_name = params.get("function_name", "")
-    vuln_type = params.get("vulnerability_type", "")
+def submit_function(ctx: Any, qkey: str, params: Dict) -> Tuple[str, Reward]:
+    """Handle SUBMIT_FUNCTION action for Task 1.
+ 
+    Expected params
+    ---------------
+    function_name     : str  – name of the vulnerable function
+    vulnerability_type: str  – short description of the vulnerability
+    """
+    if ctx._submitted:
+        return (
+            "❌ You have already submitted for this episode. "
+            "Only ONE submission is allowed.",
+            Reward(value=0.0, reason="Second submit_function attempt", partial=False),
+        )
+ 
+    fn_name   = params.get("function_name", "").strip()
+    vuln_type = params.get("vulnerability_type", "").strip()
+ 
     if not fn_name or not vuln_type:
         return (
-            "Submit requires 'function_name' and 'vulnerability_type' in params.",
-            Reward(value=-0.5, reason="Malformed submission", partial=True),
+            "submit_function requires both 'function_name' and "
+            "'vulnerability_type' in params.",
+            Reward(value=0.0, reason="Malformed submission", partial=False),
         )
-    score = ctx._grader.grade_submission(fn_name, vuln_type)
-    reward_val = ctx._grader.reward_for_score(score)
-    ctx._done = True
-
+ 
+    ctx._submitted = True
+    ctx._done      = True
+ 
+    score      = ctx._grader.grade_submission(fn_name, vuln_type)   # {0.0, 0.5, 1.0}
+    reward_val = ctx._grader.reward_for_score(score)                 # [0.0, 1.0]
+    correct    = ctx._grader.get_canonical_answer()
+ 
     if score == 1.0:
         msg = (
-            f"✅ CORRECT! '{fn_name}' is the vulnerable function. "
-            f"Vulnerability type '{vuln_type}' matches. Score: 1.0"
+            f"✅ CORRECT! '{fn_name}' is the vulnerable function "
+            f"and the vulnerability type matches. "
+            f"Score: 1.0 → Reward: {reward_val:.3f}"
         )
     elif score == 0.5:
         msg = (
-            f"⚠️  PARTIAL. '{fn_name}' is the right function, but the vulnerability type "
-            f"'{vuln_type}' was not precise. Score: 0.5"
+            f"🟡 PARTIAL. '{fn_name}' is the correct function but the "
+            f"vulnerability type was not recognised. "
+            f"Score: 0.5 → Reward: {reward_val:.3f}. "
+            f"Expected vulnerability: '{correct['vulnerability']}'."
         )
     else:
-        correct = ctx._grader.get_canonical_answer()
         msg = (
-            f"❌ INCORRECT. '{fn_name}' is not the target vulnerable function. "
-            f"Correct answer: {correct['function']} ({correct['vulnerability']}). Score: 0.0"
+            f"❌ INCORRECT. '{fn_name}' is not the target function. "
+            f"Score: 0.0 → Reward: {reward_val:.3f}. "
+            f"Correct answer: function='{correct['function']}', "
+            f"vulnerability='{correct['vulnerability']}'."
         )
+ 
     return msg, Reward(
         value=reward_val,
-        reason=f"Submission score={score:.1f}",
+        reason=f"submit_function score={score:.1f}",
         partial=False,
     )
 

server/tasks/task1/grader.py

@@ -1,30 +1,58 @@
 """
 grader.py  (Task 1 – Targeted Vulnerability Detection)
 -------------------------------------------------------
-Deterministic grader. Score range: 0.0 – 1.0
+Deterministic grader. Grade range: 0.0 – 1.0
 
   1.0 – correct function + correct vulnerability keyword
   0.5 – correct function + wrong/unrecognised vulnerability keyword
   0.0 – wrong function name
+
+reward_for_score() normalises the raw RL reward to [0.0, 1.0]
+using the fixed reward bounds [MIN_REWARD=-1.5, MAX_REWARD=5.0]:
+  normalised = (raw + 1.5) / 6.5
 """
 from __future__ import annotations
 from typing import Dict
 from utils import SemanticMatcher
 
+# Raw reward bounds — used only for normalisation
+_MIN_REWARD = -1.5
+_MAX_REWARD =  5.0
+_REWARD_RANGE = _MAX_REWARD - _MIN_REWARD  # 6.5
+
+_SCORE_MIN = 0.001   # grades are strictly (0, 1)
+_SCORE_MAX = 0.999
+
+
+def _clamp(v: float) -> float:
+    return max(_SCORE_MIN, min(_SCORE_MAX, v))
+
+
 class Task1Grader:
     def __init__(self, target_function: str, vulnerability_issue: str) -> None:
-        self.target_function = target_function.lower()
+        self.target_function     = target_function.lower()
         self.vulnerability_issue = vulnerability_issue
 
     def grade_submission(self, submitted_function: str, submitted_vuln_type: str) -> float:
+        """Returns grade strictly in (0, 1)."""
         if submitted_function.strip().lower() != self.target_function:
-            return 0.0
-        return 1.0 if SemanticMatcher().match(self.vulnerability_issue, submitted_vuln_type) else 0.5
+            return _clamp(0.0)   # → 0.001
+        return _clamp(1.0) if SemanticMatcher().match(self.vulnerability_issue, submitted_vuln_type) else _clamp(0.5)
 
     def reward_for_score(self, score: float) -> float:
-        if score == 1.0: return 5.0
-        if score == 0.5: return 1.0
-        return -1.5
+        """
+        Maps grade score → normalised reward strictly in (0, 1).
+
+        Raw rewards:  correct=+5.0, partial=+1.0, wrong=-1.5
+        Normalised:   (raw + 1.5) / 6.5  then clamped to (0.001, 0.999)
+        """
+        if score >= _SCORE_MAX:
+            raw = 5.0
+        elif score >= 0.5:
+            raw = 1.0
+        else:
+            raw = -1.5
+        return _clamp((raw - _MIN_REWARD) / _REWARD_RANGE)
 
     def get_canonical_answer(self) -> Dict[str, str]:
-        return {"function": self.target_function, "vulnerability": self.vulnerability_issue}
+        return {"function": self.target_function, "vulnerability": self.vulnerability_issue}

server/tasks/task2/actions.py

@@ -105,30 +105,53 @@ def get_similar_rule_action(ctx: Any, qkey: str, params: Dict) -> Tuple[str, Rew
 
 
 def submit_property(ctx: Any, qkey: str, params: Dict) -> Tuple[str, Reward]:
-    """Handle SUBMIT_PROPERTY action."""
+    """Handle SUBMIT_PROPERTY action for Task 2.
+ 
+    Expected params
+    ---------------
+    property : str  – natural-language property describing the function's behaviour
+    """
     if ctx._submitted:
         return (
-            "❌ You have already submitted a property for this episode. "
-            "Only one submission is allowed.",
-            Reward(value=-1.0, reason="Second submit_property attempt", partial=False),
+            "❌ You have already submitted for this episode. "
+            "Only ONE submission is allowed.",
+            Reward(value=0.0, reason="Second submit_property attempt", partial=False),
         )
-
-    submitted_text = params.get("property", "").strip()
-    if not submitted_text:
+ 
+    submitted_property = params.get("property", "").strip()
+ 
+    if not submitted_property:
         return (
-            "Submit requires 'property' key in params with a non-empty string.",
-            Reward(value=-0.5, reason="Empty property submission"),
+            "submit_property requires a non-empty 'property' string in params.",
+            Reward(value=0.0, reason="Malformed submission", partial=False),
         )
-
+ 
     ctx._submitted = True
-    ctx._done = True
-    score, confidence = ctx._grader.grade(submitted_text)
-    reward = round(score * 5.0, 4)
-
-    msg = f'Score: {score:.2f}/1.00 → Confidence: {confidence}\n'    
+    ctx._done      = True
+ 
+    # grade() returns (float score in [0,1], confidence str)
+    score, confidence = ctx._grader.grade(submitted_property)  # score already in [0.0, 1.0]
+    reward_val        = float(score)                           # reward == grade for Task 2
+ 
+    if confidence == "strong":
+        msg = (
+            f"✅ STRONG MATCH. Your property closely matches the target. "
+            f"Score: {score:.3f} → Reward: {reward_val:.3f}"
+        )
+    elif confidence == "moderate":
+        msg = (
+            f"🟡 MODERATE MATCH. Your property partially captures the target behaviour. "
+            f"Score: {score:.3f} → Reward: {reward_val:.3f}"
+        )
+    else:
+        msg = (
+            f"❌ LOW MATCH. Your property does not sufficiently match the target. "
+            f"Score: {score:.3f} → Reward: {reward_val:.3f}"
+        )
+ 
     return msg, Reward(
-        value=reward,
-        reason=f"Property submission score={score:.3f}",
+        value=reward_val,
+        reason=f"submit_property confidence={confidence} score={score:.3f}",
         partial=False,
     )
 

server/tasks/task2/grader.py

@@ -3,15 +3,17 @@ grader.py  (Task 2 – Property Discovery)
 -----------------------------------------
 Deterministic scorer for natural-language property submissions.
 One submission attempt per episode.
+Grade range: 0.0 – 1.0  (matchscore output, already normalised).
 """
 
-from __future__ import annotations
-
 from typing import Tuple
 from utils import SemanticMatcher
 
+_SCORE_MIN = 0.001   # grades are strictly (0, 1)
+_SCORE_MAX = 0.999
 
-# ── Grader ────────────────────────────────────────────────────────────────────
+def _clamp(v: float) -> float:
+    return max(_SCORE_MIN, min(_SCORE_MAX, v))
 
 class Task2Grader:
     """
@@ -19,23 +21,19 @@ class Task2Grader:
 
     Parameters
     ----------
-    function_name  : name of the target function
-    property  : the 'property' field from the target function's data
+    function_name : name of the target function
+    property      : the 'property' field from the target function's data
     """
 
     def __init__(self, function_name: str, property: str) -> None:
-        self.function_name    = function_name
-        self.property         = property
-
-    # ── Public API ────────────────────────────────────────────────────────────
+        self.function_name = function_name
+        self.property      = property
 
     def grade(self, submitted: str) -> Tuple[float, str]:
-        """Deterministic score in [0.0, 1.0]."""
+        """Deterministic grade strictly in (0, 1)."""
         if not submitted or not submitted.strip():
-            return 0.0, "no_match"
+            return _clamp(0.0), "no_match"   # → 0.001
 
-        SemanticMatcherInstance = SemanticMatcher()
-        return (
-            SemanticMatcherInstance.matchscore(self.property, submitted), 
-            SemanticMatcherInstance.confidence()
-        )
+        matcher = SemanticMatcher()
+        score   = matcher.matchscore(self.property, submitted)  # already clamped by SemanticMatcher
+        return _clamp(score), matcher.confidence()

server/tasks/task3/actions.py

@@ -126,44 +126,52 @@ def get_property_specification(ctx: Any, qkey: str, params: Dict) -> Tuple[str,
 
 
 def submit_function(ctx: Any, qkey: str, params: Dict) -> Tuple[str, Reward]:
-    """Handle SUBMIT_FUNCTION action."""
+    """Handle SUBMIT_FUNCTION action for Task 3.
+ 
+    Expected params
+    ---------------
+    function_name : str  – name of the function that violates the given property
+    """
     if ctx._submitted:
         return (
             "❌ You have already submitted for this episode. "
             "Only ONE submission is allowed.",
-            Reward(value=-1.0, reason="Second submit_function attempt", partial=False),
+            Reward(value=0.0, reason="Second submit_function attempt", partial=False),
         )
+ 
     fn_name = params.get("function_name", "").strip()
+ 
     if not fn_name:
         return (
             "submit_function requires 'function_name' in params.",
-            Reward(value=-0.5, reason="Malformed submission"),
+            Reward(value=0.0, reason="Malformed submission", partial=False),
         )
-
+ 
     ctx._submitted = True
-    ctx._done = True
-    score, reward_val = ctx._grader.grade_and_reward(fn_name)
-    correct = ctx._grader.get_canonical_answer()
-
+    ctx._done      = True
+ 
+    score, reward_val = ctx._grader.grade_and_reward(fn_name)  # reward_val in [0.0, 1.0]
+    correct           = ctx._grader.get_canonical_answer()
+ 
     if score >= 0.9:
         msg = (
             f"✅ CORRECT! '{fn_name}' is the function that violates the property. "
-            f"Score: 1.0 → Reward: +{reward_val:.1f}"
+            f"Score: 1.0 → Reward: {reward_val:.3f}"
         )
     elif score >= 0.2:
         msg = (
-            f"🟡 PARTIAL. '{fn_name}' is a subfunction of the target — "
+            f"🟡 PARTIAL. '{fn_name}' is an internal subfunction of the target — "
             f"closely related but not the primary rule-breaker. "
-            f"Score: 0.3 → Reward: +{reward_val:.1f}. "
-            f"Correct answer: '{correct['target_function']}'."
+            f"Score: 0.3 → Reward: {reward_val:.3f}. "
+            f"Correct answer: '{correct['target_function']['name']}'."
         )
     else:
         msg = (
             f"❌ INCORRECT. '{fn_name}' does not violate the property. "
-            f"Score: 0.0 → Reward: {reward_val:.1f}. "
-            f"Correct answer: '{correct['target_function']}'."
+            f"Score: 0.0 → Reward: {reward_val:.3f}. "
+            f"Correct answer: '{correct['target_function']['name']}'."
         )
-
+ 
     return msg, Reward(
         value=reward_val,
         reason=f"submit_function score={score:.1f}",

server/tasks/task3/grader.py

@@ -3,23 +3,29 @@ grader.py  (Task 3 – Rule Checker)
 ------------------------------------
 Deterministic grader for function-identification submissions.
 
-Score table
+Grade table
 ───────────
   1.0  → submitted function is the exact target (case-insensitive)
   0.3  → submitted function is a direct internal subfunction of the target
-         (a contract-internal function called by the target in the call graph)
   0.0  → anything else
 
-Reward table (ONE submission per episode)
-  score 1.0  → +5.0
-  score 0.3  → +1.5
-  score 0.0  → -1.5
+reward_for_score() normalises the raw RL reward to [0.0, 1.0]
+using the fixed reward bounds [MIN_REWARD=-1.5, MAX_REWARD=5.0]:
+  normalised = (raw + 1.5) / 6.5
 """
 
-from __future__ import annotations
 import json
 from typing import Dict, Any
 
+_T3_MIN_REWARD   = -1.5
+_T3_MAX_REWARD   =  5.0
+_T3_REWARD_RANGE = _T3_MAX_REWARD - _T3_MIN_REWARD  # 6.5
+
+_SCORE_MIN = 0.001   # grades are strictly (0, 1
+_SCORE_MAX = 0.999
+
+def _clamp(v: float) -> float:
+    return max(_SCORE_MIN, min(_SCORE_MAX, v))
 
 class Task3Grader:
     """
@@ -27,25 +33,26 @@ class Task3Grader:
 
     Parameters
     ----------
-    target_function         : exact name of the rule-breaking function
-    partial_credit_functions: list of internal functions that get partial credit
-                              (direct callees of the target that are contract functions)
+    target_function          : dict with at least 'name' and 'code' keys
+    property_specification   : the property the target function violates
     """
+    
+    # Raw reward bounds — used only for normalisation
+    _MIN_REWARD = -1.5
+    _MAX_REWARD =  5.0
+    _REWARD_RANGE = _MAX_REWARD - _MIN_REWARD  # 6.5
 
-    SCORE_CORRECT  = 1.0
-    SCORE_PARTIAL  = 0.3
-    SCORE_WRONG    = 0.0
 
-    REWARD_CORRECT = 5.0
-    REWARD_PARTIAL = 1.5
-    REWARD_WRONG   = -1.5
+    SCORE_CORRECT = _clamp(1.0)   # 0.999
+    SCORE_PARTIAL = _clamp(0.3)   # 0.300  (already inside (0,1))
+    SCORE_WRONG   = _clamp(0.0)   # 0.001
 
     def __init__(self, target_function: Dict[str, Any], property_specification: Dict | str) -> None:
-        self.target_function = target_function
+        self.target_function        = target_function
         self.property_specification = property_specification
 
     def grade(self, submitted_function: str) -> float:
-        """Returns deterministic score in {0.0, 0.3, 1.0}."""
+        """Returns deterministic grade strictly in (0, 1)."""
         norm = submitted_function.strip().lower()
         if norm == self.target_function["name"].strip().lower():
             return self.SCORE_CORRECT
@@ -54,22 +61,29 @@ class Task3Grader:
         return self.SCORE_WRONG
 
     def reward_for_score(self, score: float) -> float:
-        """Maps score → terminal reward."""
+        """
+        Maps grade score → normalised reward strictly in (0, 1).
+
+        Raw rewards:  correct=+5.0, partial=+1.5, wrong=-1.5
+        Normalised:   (raw + 1.5) / 6.5  then clamped to (0.001, 0.999)
+        """
         if score >= 0.9:
-            return self.REWARD_CORRECT
-        if score >= 0.2:
-            return self.REWARD_PARTIAL
-        return self.REWARD_WRONG
+            raw = 5.0
+        elif score >= 0.2:
+            raw = 1.5
+        else:
+            raw = -1.5
+        return _clamp((raw - _T3_MIN_REWARD) / _T3_REWARD_RANGE)
 
     def grade_and_reward(self, submitted_function: str):
-        """Convenience: returns (score, reward)."""
+        """Convenience: returns (grade, normalised_reward), both strictly in (0, 1)."""
         score = self.grade(submitted_function)
         return score, self.reward_for_score(score)
 
     def get_canonical_answer(self) -> Dict[str, Dict | str]:
         """For debugging / logging only — do not expose to the agent."""
         return {
-            "target_function":          self.target_function,
-            "property_specification": json.dumps(self.property_specification) 
+            "target_function":        self.target_function,
+            "property_specification": json.dumps(self.property_specification)
                 if isinstance(self.property_specification, dict) else self.property_specification,
-        }
+        }

utils/prompts.py

@@ -2,6 +2,10 @@ T1_SYSTEM = """You are an expert Solidity smart contract security auditor.
 
 Given a contract, identify the ONE vulnerable function and its vulnerability type.
 
+Negative reward is given for each information-gathering action, so be strategic. 
+Focus on high-signal actions like get_function_code and get_function_summary, and only inspect 
+state variables or call graphs if you have a strong suspicion.
+
 ## Actions (choose ONE per turn, respond with JSON only):
 {"action": "list_functions",       "params": {}}
 {"action": "get_function_code",    "params": {"function_name": "<name>"}}
@@ -35,6 +39,10 @@ You will be shown a specific Solidity function. Your task is to write a precise
 natural-language property (invariant / postcondition) that describes what the
 function guarantees when it succeeds.
 
+Negative reward is given for each information-gathering action, so be strategic. 
+Focus on high-signal actions like get_function_code and get_function_summary, and only inspect 
+state variables or call graphs if you have a strong suspicion.
+
 A good property covers:
   - What state changes (balances, counters, flags)
   - What assets are transferred (ETH, tokens, NFTs)
@@ -72,6 +80,10 @@ T3_SYSTEM = """You are a smart contract security auditor checking rule complianc
 You are given a Solidity contract and a property (rule) in natural English.
 Your task is to find the ONE function that violates this property.
 
+Negative reward is given for each information-gathering action, so be strategic. 
+Focus on high-signal actions like get_function_code and get_function_summary, and only inspect 
+state variables or call graphs if you have a strong suspicion.
+
 ## Actions (respond with JSON only, ONE action per turn):
 {"action": "list_functions",          "params": {}}
 {"action": "get_property_specification", "params": {}}

utils/semanticmatcher.py

@@ -143,6 +143,17 @@ def cosine_similarity(vec_a: np.ndarray, vec_b: np.ndarray) -> float:
     return float(np.dot(vec_a, vec_b) / (norm_a * norm_b))
 
 
+# ── Score clamping ───────────────────────────────────────────────────────────
+
+_SCORE_MIN = 0.001   # scores are strictly (0, 1) — never touch 0 or 1
+_SCORE_MAX = 0.999
+
+
+def _clamp(score: float) -> float:
+    """Clamp score to the open interval (0, 1): [_SCORE_MIN, _SCORE_MAX]."""
+    return max(_SCORE_MIN, min(_SCORE_MAX, score))
+
+
 # ── Core matcher ──────────────────────────────────────────────────────────────
 
 class SemanticMatcher:
@@ -201,7 +212,7 @@ class SemanticMatcher:
         # Fast-path: normalized exact match
         if normalize(text_a) == normalize(text_b):
             self.confidence_level = "strong"
-            return True
+            return _clamp(1.0)   # → 0.999  (strictly less than 1)
 
         tokens_a = tokenize_and_lemmatize(text_a)
         tokens_b = tokenize_and_lemmatize(text_b)
@@ -219,13 +230,13 @@ class SemanticMatcher:
             self.confidence_level = "moderate"
         else:
             self.confidence_level = "no_match"
-        return score
-    
+        return _clamp(score)   # strictly in (0, 1)
+
     def match(self, text_a: str, text_b: str) -> bool:
         """Return True if the two texts are considered a match based on the score."""
         score = self.matchscore(text_a, text_b)
         return score >= self.match_threshold
-    
+
     def confidence(self) -> str:
-        """Return 'strong' if score ≥ strong_threshold, else 'weak'."""
+        """Return 'strong' if score ≥ strong_threshold, else 'moderate' or 'no_match'."""
         return self.confidence_level