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

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/0040_738_40738491_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/0040_738_40738491_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/0040_738_40738491_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/0040_748_40748661_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/0040_748_40748661_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/0040_748_40748661_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/0040_756_40756003_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/0040_776_40776095_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/0040_783_40783338_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/0040_785_40785152_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/0040_785_40785152_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/0040_788_40788057_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/0040_788_40788057_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/0040_788_40788908_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/0040_789_40789473_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/0040_789_40789473_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/0040_805_40805436_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/0040_808_40808132_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/0040_826_40826860_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/0040_826_40826860_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/0040_843_40843458_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/0040_843_40843458_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/0040_853_40853543_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/0040_880_40880494_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/0040_896_40896108_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/0040_916_40916847_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/0040_921_40921599_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/0040_929_40929685_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/0040_929_40929691_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/0040_930_40930969_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/0040_981_40981860_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/0040_981_40981860_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/0040_983_40983485_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/0040_983_40983485_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/0041_009_41009075_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/0041_015_41015677_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/0041_015_41015677_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/0041_018_41018707_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/0041_018_41018707_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/0041_020_41020843_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/0041_020_41020843_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/0041_034_41034683_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/0041_035_41035825_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/0041_074_41074160_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/0041_084_41084912_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/0041_143_41143507_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/0041_145_41145764_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/0041_145_41145764_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/0041_156_41156002_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/0041_156_41156002_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