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

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/0022_076_22076548_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/0022_076_22076548_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/0022_122_22122831_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/0022_169_22169428_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/0022_193_22193578_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/0022_193_22193578_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/0022_210_22210529_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/0022_258_22258436_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/0022_258_22258436_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/0022_258_22258436_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/0022_258_22258436_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/0022_272_22272220_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/0022_383_22383259_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/0022_423_22423880_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/0022_457_22457642_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/0022_457_22457642_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/0022_482_22482992_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/0022_555_22555686_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/0022_609_22609620_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/0022_668_22668393_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/0022_704_22704559_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/0022_712_22712745_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/0022_788_22788694_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/0022_790_22790047_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/0022_860_22860039_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/0022_886_22886038_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/0022_916_22916338_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/0022_916_22916338_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/0022_928_22928479_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/0022_941_22941609_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/0023_186_23186300_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/0023_251_23251738_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/0023_251_23251738_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/0023_425_23425201_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/0023_426_23426961_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/0023_468_23468316_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/0023_468_23468316_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/0023_531_23531492_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/0023_531_23531492_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/0023_580_23580177_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/0023_583_23583710_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/0023_598_23598239_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/0023_598_23598239_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/0023_626_23626093_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/0023_626_23626093_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/0023_670_23670397_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/0023_684_23684693_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/0023_715_23715177_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/0023_715_23715177_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/0023_721_23721314_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