SmolDataEnvs-harbor-train: remove null tool_efficiency from graders (part 11)

On 3,331/5,000 train tasks, `test.sh` pipes `grader.py --json` to `reward.json`. Its null `tool_efficiency` (no tool-call count is written) makes Harbor reject the whole reward, correctness included, for every answered trial; only empty submissions grade as 0. The other 1,669 tasks write a plain number to `reward.txt` without `--json` and are unaffected.

This copies the already-fixed test-split `grader.py` byte for byte to all 5,000 tasks. Only `tool_efficiency` is removed; `grade()`, tolerances and normalisation stay the same. `test.sh` and all other files are unchanged.

### Testing

JSON after the change: correct `{"correctness": 1.0, "submission": 1.0}`; empty `{"correctness": 0.0, "submission": 0.0}`.

tasks/0130_334_130334137_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_334_130334137_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_347_130347840_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_588_130588060_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_615_130615633_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_615_130615633_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_710_130710766_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_713_130713633_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_740_130740848_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_751_130751962_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_870_130870201_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_890_130890369_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_890_130890369_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0130_998_130998781_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_072_131072256_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_072_131072256_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_224_131224079_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_249_131249802_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_258_131258497_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_341_131341778_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_433_131433565_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_433_131433565_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_438_131438357_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_454_131454088_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_454_131454088_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_458_131458182_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_552_131552856_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_609_131609730_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_609_131609730_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_609_131609730_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_622_131622026_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_624_131624769_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_667_131667789_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_731_131731169_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_767_131767840_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_767_131767840_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_881_131881806_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0131_881_131881806_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_089_132089829_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_099_132099772_qa_3/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_138_132138987_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_151_132151183_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_151_132151183_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_169_132169068_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_236_132236539_qa_5/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_270_132270430_qa_1/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_270_132270430_qa_4/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_290_132290375_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_422_132422220_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0
 

tasks/0132_434_132434308_qa_2/tests/grader.py

@@ -106,28 +106,20 @@ def grade(gold: str, candidate: str, *, question: str = "", reward_mode: str = "
     return GradeResult(0.0, "miss")
 
 
-def _tool_calls():
-    try:
-        with open("/workdir/.n_tool_calls") as fh:
-            return int(fh.read().strip())
-    except (OSError, ValueError):
-        pass
-    raw = os.environ.get("N_TOOL_CALLS")
-    if raw is not None:
-        try:
-            return int(str(raw).strip())
-        except ValueError:
-            return None
-    return None
-
-
-def _tool_efficiency(n):
-    if n is None:
-        return None
-    budget = float(os.environ.get("TOOL_BUDGET", "15") or "15")
-    if budget <= 0:
-        return None
-    return max(0.0, min(1.0, 1.0 - n / budget))
+# TOOL EFFICIENCY IS NOT COMPUTED HERE, AND CANNOT BE.
+#
+# This grader used to emit a `tool_efficiency` key derived from a tool-call count it read from
+# `/workdir/.n_tool_calls` or `$N_TOOL_CALLS`. Nothing writes that file and no task.toml sets that
+# variable, so the count was always None, the key was always null, and Harbor's reward model
+# (`dict[str, float | int]`) rejected the WHOLE dict -- taking `correctness` down with it. The only
+# path that survived was the empty-submission branch below, so the suite graded failures correctly
+# and crashed on every successful answer. That silently removed 86 of 250 tasks from scoring.
+#
+# The count is not the sandbox's to know: it lives in the capture proxy, which sees every model call.
+# A reward belongs in the verifier only if the sandbox is what makes it computable. Correctness needs
+# the data, the gold answer and the tolerances -- it belongs here. Tool efficiency needs a trace --
+# it belongs to whoever holds the trace, and it is computed there as a shaping term, gated on
+# correctness so that "made no tool calls" can never outscore solving the task.
 
 
 def _tols():
@@ -156,12 +148,11 @@ def main_json() -> int:
     question = (os.environ.get("QUESTION") or "").strip()
     candidate = sys.stdin.read().strip()
     if not candidate:
-        print(json.dumps({"correctness": 0.0, "submission": 0.0, "tool_efficiency": 0.0}))
+        print(json.dumps({"correctness": 0.0, "submission": 0.0}))
         return 0
     at, rt = _tols()
     r = grade(gold, candidate, question=question, reward_mode=os.environ.get("REWARD_MODE", "") or "", abs_tol=at, rel_tol=rt)
-    n = _tool_calls()
-    print(json.dumps({"correctness": float(r.reward), "submission": 1.0, "tool_efficiency": _tool_efficiency(n)}))
+    print(json.dumps({"correctness": float(r.reward), "submission": 1.0}))
     print(f"[grader] gold={gold!r} pred={candidate[:80]!r} correctness={r.reward} method={r.method}", file=sys.stderr)
     return 0